diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -1611,6 +1611,12 @@ ElementCount computeFeasibleMaxVF(unsigned ConstTripCount, ElementCount UserVF); + ElementCount getScalableVFBound(unsigned MaxSafeElements); + + ElementCount getMaxVectorSize(unsigned SmallestType, unsigned WidestType, + ElementCount MaxVFBound, + Optional ConstTCBound); + /// The vectorization cost is a combination of the cost itself and a boolean /// indicating whether any of the contributing operations will actually /// operate on @@ -5668,135 +5674,106 @@ return None; } +static ElementCount minElementCount(ElementCount A, ElementCount B) { + assert((!A.isScalable() && !B.isScalable()) || + (A.isScalable() && B.isScalable()) && + "can only be used for element counts with matching sigedness"); + if (ElementCount::isKnownLE(A, B)) + return A; + // Is this needed or always guaranteed? + assert(ElementCount::isKnownGT(A, B)); + return B; +} + ElementCount -LoopVectorizationCostModel::computeFeasibleMaxVF(unsigned ConstTripCount, - ElementCount UserVF) { - bool IgnoreScalableUserVF = UserVF.isScalable() && - !TTI.supportsScalableVectors() && - !ForceTargetSupportsScalableVectors; - if (IgnoreScalableUserVF) { - LLVM_DEBUG( - dbgs() << "LV: Ignoring VF=" << UserVF - << " because target does not support scalable vectors.\n"); +LoopVectorizationCostModel::getScalableVFBound(unsigned MaxSafeElements) { + ElementCount ScalableVFBound = ElementCount::getScalable(1u << 16); + // Display remark if scalable vectorization is requested but not supported by + // the target. + if (!TTI.supportsScalableVectors() && !ForceTargetSupportsScalableVectors) { + LLVM_DEBUG(dbgs() << "LV: Disabling scalable vectorization, because target " + "does not support scalable vectors.\n"); ORE->emit([&]() { return OptimizationRemarkAnalysis(DEBUG_TYPE, "IgnoreScalableUserVF", TheLoop->getStartLoc(), TheLoop->getHeader()) - << "Ignoring VF=" << ore::NV("UserVF", UserVF) - << " because target does not support scalable vectors."; + << "Disabling scalable vectorization, because target does not " + "support scalable vectors.\n"; }); + return ElementCount::getScalable(0); } - // Beyond this point two scenarios are handled. If UserVF isn't specified - // then a suitable VF is chosen. If UserVF is specified and there are - // dependencies, check if it's legal. However, if a UserVF is specified and - // there are no dependencies, then there's nothing to do. - if (UserVF.isNonZero() && !IgnoreScalableUserVF) { - if (!canVectorizeReductions(UserVF)) { - reportVectorizationFailure( - "LV: Scalable vectorization not supported for the reduction " - "operations found in this loop. Using fixed-width " - "vectorization instead.", - "Scalable vectorization not supported for the reduction operations " - "found in this loop. Using fixed-width vectorization instead.", - "ScalableVFUnfeasible", ORE, TheLoop); - return computeFeasibleMaxVF( - ConstTripCount, ElementCount::getFixed(UserVF.getKnownMinValue())); - } - - if (Legal->isSafeForAnyVectorWidth()) - return UserVF; - } - - MinBWs = computeMinimumValueSizes(TheLoop->getBlocks(), *DB, &TTI); - unsigned SmallestType, WidestType; - std::tie(SmallestType, WidestType) = getSmallestAndWidestTypes(); - unsigned WidestRegister = TTI.getRegisterBitWidth(true); - - // Get the maximum safe dependence distance in bits computed by LAA. - // It is computed by MaxVF * sizeOf(type) * 8, where type is taken from - // the memory accesses that is most restrictive (involved in the smallest - // dependence distance). - unsigned MaxSafeVectorWidthInBits = Legal->getMaxSafeVectorWidthInBits(); - - // If the user vectorization factor is legally unsafe, clamp it to a safe - // value. Otherwise, return as is. - if (UserVF.isNonZero() && !IgnoreScalableUserVF) { - unsigned MaxSafeElements = - PowerOf2Floor(MaxSafeVectorWidthInBits / WidestType); - ElementCount MaxSafeVF = ElementCount::getFixed(MaxSafeElements); - - if (UserVF.isScalable()) { - Optional MaxVScale = TTI.getMaxVScale(); - - // Scale VF by vscale before checking if it's safe. - MaxSafeVF = ElementCount::getScalable( - MaxVScale ? (MaxSafeElements / MaxVScale.getValue()) : 0); - - if (MaxSafeVF.isZero()) { - // The dependence distance is too small to use scalable vectors, - // fallback on fixed. - LLVM_DEBUG( - dbgs() - << "LV: Max legal vector width too small, scalable vectorization " - "unfeasible. Using fixed-width vectorization instead.\n"); - ORE->emit([&]() { - return OptimizationRemarkAnalysis(DEBUG_TYPE, "ScalableVFUnfeasible", - TheLoop->getStartLoc(), - TheLoop->getHeader()) - << "Max legal vector width too small, scalable vectorization " - << "unfeasible. Using fixed-width vectorization instead."; - }); - return computeFeasibleMaxVF( - ConstTripCount, ElementCount::getFixed(UserVF.getKnownMinValue())); - } + // Disable scalable vectorization, if the loop contains unsupported + // reductions. + if (!canVectorizeReductions(ScalableVFBound)) { + reportVectorizationFailure( + "LV: Scalable vectorization not supported for the reduction " + "operations found in this loop. Using fixed-width " + "vectorization instead.", + "Scalable vectorization not supported for the reduction operations " + "found in this loop. Using fixed-width vectorization instead.", + "ScalableVFUnfeasible", ORE, TheLoop); + return ElementCount::getScalable(0); + } + + // Limit ScalableVFBound by the maximum safe dependence distance. + if (!Legal->isSafeForAnyVectorWidth()) { + Optional MaxVScale = TTI.getMaxVScale(); + + // Scale VF by vscale before checking if it's safe. + ScalableVFBound = ElementCount::getScalable( + MaxVScale ? (MaxSafeElements / MaxVScale.getValue()) : 0); + + if (ScalableVFBound.isZero()) { + // The dependence distance is too small to use scalable vectors, + // fallback on fixed. + LLVM_DEBUG( + dbgs() + << "LV: Max legal vector width too small, scalable vectorization " + "unfeasible. Using fixed-width vectorization instead.\n"); + ORE->emit([&]() { + return OptimizationRemarkAnalysis(DEBUG_TYPE, "ScalableVFUnfeasible", + TheLoop->getStartLoc(), + TheLoop->getHeader()) + << "Max legal vector width too small, scalable vectorization " + << "unfeasible. Using fixed-width vectorization instead."; + }); } - - LLVM_DEBUG(dbgs() << "LV: The max safe VF is: " << MaxSafeVF << ".\n"); - - if (ElementCount::isKnownLE(UserVF, MaxSafeVF)) - return UserVF; - - LLVM_DEBUG(dbgs() << "LV: User VF=" << UserVF - << " is unsafe, clamping to max safe VF=" << MaxSafeVF - << ".\n"); - ORE->emit([&]() { - return OptimizationRemarkAnalysis(DEBUG_TYPE, "VectorizationFactor", - TheLoop->getStartLoc(), - TheLoop->getHeader()) - << "User-specified vectorization factor " - << ore::NV("UserVectorizationFactor", UserVF) - << " is unsafe, clamping to maximum safe vectorization factor " - << ore::NV("VectorizationFactor", MaxSafeVF); - }); - return MaxSafeVF; } - WidestRegister = std::min(WidestRegister, MaxSafeVectorWidthInBits); + return ScalableVFBound; +} +ElementCount LoopVectorizationCostModel::getMaxVectorSize( + unsigned SmallestType, unsigned WidestType, ElementCount MaxVFBound, + Optional ConstTCBound) { + unsigned WidestRegister = + MaxVFBound.isScalable() ? 128 : TTI.getRegisterBitWidth(true); // Ensure MaxVF is a power of 2; the dependence distance bound may not be. // Note that both WidestRegister and WidestType may not be a powers of 2. - auto MaxVectorSize = - ElementCount::getFixed(PowerOf2Floor(WidestRegister / WidestType)); + auto MaxVectorSize = ElementCount::get( + PowerOf2Floor(WidestRegister / WidestType), MaxVFBound.isScalable()); + // Clamp to maximum legal VF. + MaxVectorSize = minElementCount(MaxVectorSize, MaxVFBound); - LLVM_DEBUG(dbgs() << "LV: The Smallest and Widest types: " << SmallestType - << " / " << WidestType << " bits.\n"); LLVM_DEBUG(dbgs() << "LV: The Widest register safe to use is: " << WidestRegister << " bits.\n"); - assert(MaxVectorSize.getFixedValue() <= WidestRegister && + assert(MaxVectorSize.getKnownMinValue() <= WidestRegister && "Did not expect to pack so many elements" " into one vector!"); - if (MaxVectorSize.getFixedValue() == 0) { + if (MaxVectorSize.isZero()) { LLVM_DEBUG(dbgs() << "LV: The target has no vector registers.\n"); - return ElementCount::getFixed(1); - } else if (ConstTripCount && ConstTripCount < MaxVectorSize.getFixedValue() && - isPowerOf2_32(ConstTripCount)) { + return ElementCount::get(1, MaxVFBound.isScalable()); + } + if (ConstTCBound && + minElementCount(MaxVectorSize, *ConstTCBound) != MaxVectorSize && + isPowerOf2_32(ConstTCBound->getKnownMinValue())) { // We need to clamp the VF to be the ConstTripCount. There is no point in // choosing a higher viable VF as done in the loop below. LLVM_DEBUG(dbgs() << "LV: Clamping the MaxVF to the constant trip count: " - << ConstTripCount << "\n"); - return ElementCount::getFixed(ConstTripCount); + << *ConstTCBound << "\n"); + return *ConstTCBound; } ElementCount MaxVF = MaxVectorSize; @@ -5805,8 +5782,13 @@ // Collect all viable vectorization factors larger than the default MaxVF // (i.e. MaxVectorSize). SmallVector VFs; - auto MaxVectorSizeMaxBW = - ElementCount::getFixed(WidestRegister / SmallestType); + auto MaxVectorSizeMaxBW = ElementCount::get(WidestRegister / SmallestType, + MaxVFBound.isScalable()); + // Clamp to maximum legal VF. + MaxVectorSizeMaxBW = minElementCount(MaxVectorSizeMaxBW, MaxVFBound); + if (ConstTCBound) + MaxVectorSizeMaxBW = minElementCount(MaxVectorSizeMaxBW, *ConstTCBound); + for (ElementCount VS = MaxVectorSize * 2; ElementCount::isKnownLE(VS, MaxVectorSizeMaxBW); VS *= 2) VFs.push_back(VS); @@ -5840,6 +5822,84 @@ return MaxVF; } +ElementCount +LoopVectorizationCostModel::computeFeasibleMaxVF(unsigned ConstTripCount, + ElementCount UserVF) { + MinBWs = computeMinimumValueSizes(TheLoop->getBlocks(), *DB, &TTI); + unsigned SmallestType, WidestType; + std::tie(SmallestType, WidestType) = getSmallestAndWidestTypes(); + // Get the maximum safe dependence distance in bits computed by LAA. + // It is computed by MaxVF * sizeOf(type) * 8, where type is taken from + // the memory accesses that is most restrictive (involved in the smallest + // dependence distance). + unsigned MaxSafeVectorWidthInBits = Legal->getMaxSafeVectorWidthInBits(); + + // Limit maximum vectorization factors based on memory dependence constraints. + unsigned MaxSafeElements = + PowerOf2Floor(MaxSafeVectorWidthInBits / WidestType); + ElementCount FixedVFBound = ElementCount::getFixed(MaxSafeElements); + + // Compute upper bound for scalable vectorization + auto ScalableVFBound = getScalableVFBound(MaxSafeElements); + + LLVM_DEBUG(dbgs() << "LV: The max safe fixed VF is: " << FixedVFBound + << ".\n"); + LLVM_DEBUG(dbgs() << "LV: The max safe scalable VF is: " << ScalableVFBound + << ".\n"); + + // Check if UserVF can be used. If required, clamp it by the right maximum + // VF. + if (UserVF.isNonZero()) { + auto MaxSafeVF = UserVF.isScalable() ? ScalableVFBound : FixedVFBound; + + // If the UserVF can be used, return it. + if (ElementCount::isKnownLE(UserVF, MaxSafeVF)) + return UserVF; + + assert(ElementCount::isKnownGT(UserVF, MaxSafeVF)); + + // If no scalable vectorization factor is safe, revert to fixed width + // vectorization. + bool RevertToFixed = UserVF.isScalable() && MaxSafeVF.isZero(); + if (RevertToFixed) + MaxSafeVF = FixedVFBound; + + LLVM_DEBUG(dbgs() << "LV: User VF=" << UserVF + << " is unsafe, clamping to max safe VF=" << MaxSafeVF + << ".\n"); + ORE->emit([&]() { + return OptimizationRemarkAnalysis(DEBUG_TYPE, "VectorizationFactor", + TheLoop->getStartLoc(), + TheLoop->getHeader()) + << "User-specified vectorization factor " + << ore::NV("UserVectorizationFactor", UserVF) + << " is unsafe, clamping to maximum safe vectorization factor " + << ore::NV("VectorizationFactor", MaxSafeVF); + }); + if (!RevertToFixed) + return MaxSafeVF; + } + + LLVM_DEBUG(dbgs() << "LV: The Smallest and Widest types: " << SmallestType + << " / " << WidestType << " bits.\n"); + + auto Fixed = getMaxVectorSize( + SmallestType, WidestType, FixedVFBound, + ConstTripCount + ? Optional(ElementCount::getFixed(ConstTripCount)) + : None); + Optional ScalableTCBound = + ConstTripCount + ? Optional(ElementCount::getScalable( + TTI.getMaxVScale() ? (ConstTripCount / *TTI.getMaxVScale()) + : 0)) + : None; + auto Scalable = getMaxVectorSize(SmallestType, WidestType, ScalableVFBound, + ScalableTCBound); + LLVM_DEBUG(dbgs() << "LV " << Scalable << "\n"); + return Fixed; +} + VectorizationFactor LoopVectorizationCostModel::selectVectorizationFactor(ElementCount MaxVF) { // FIXME: This can be fixed for scalable vectors later, because at this stage diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/scalable-reductions.ll b/llvm/test/Transforms/LoopVectorize/AArch64/scalable-reductions.ll --- a/llvm/test/Transforms/LoopVectorize/AArch64/scalable-reductions.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/scalable-reductions.ll @@ -323,17 +323,17 @@ ; MUL ; CHECK-REMARK: Scalable vectorization not supported for the reduction operations found in this loop. Using fixed-width vectorization instead. -; CHECK-REMARK: vectorized loop (vectorization width: 8, interleaved count: 2) +; CHECK-REMARK: vectorized loop (vectorization width: 4, interleaved count: 2) define i32 @mul(i32* nocapture %a, i32* nocapture readonly %b, i64 %n) { ; CHECK-LABEL: @mul ; CHECK: vector.body: -; CHECK: %[[LOAD1:.*]] = load <8 x i32> -; CHECK: %[[LOAD2:.*]] = load <8 x i32> -; CHECK: %[[MUL1:.*]] = mul <8 x i32> %[[LOAD1]] -; CHECK: %[[MUL2:.*]] = mul <8 x i32> %[[LOAD2]] +; CHECK: %[[LOAD1:.*]] = load <4 x i32> +; CHECK: %[[LOAD2:.*]] = load <4 x i32> +; CHECK: %[[MUL1:.*]] = mul <4 x i32> %[[LOAD1]] +; CHECK: %[[MUL2:.*]] = mul <4 x i32> %[[LOAD2]] ; CHECK: middle.block: -; CHECK: %[[RDX:.*]] = mul <8 x i32> %[[MUL2]], %[[MUL1]] -; CHECK: call i32 @llvm.vector.reduce.mul.v8i32(<8 x i32> %[[RDX]]) +; CHECK: %[[RDX:.*]] = mul <4 x i32> %[[MUL2]], %[[MUL1]] +; CHECK: call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %[[RDX]]) entry: br label %for.body @@ -353,21 +353,21 @@ ; Note: This test was added to ensure we always check the legality of reductions (end emit a warning if necessary) before checking for memory dependencies ; CHECK-REMARK: Scalable vectorization not supported for the reduction operations found in this loop. Using fixed-width vectorization instead. -; CHECK-REMARK: vectorized loop (vectorization width: 8, interleaved count: 2) +; CHECK-REMARK: vectorized loop (vectorization width: 4, interleaved count: 2) define i32 @memory_dependence(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i64 %n) { ; CHECK-LABEL: @memory_dependence ; CHECK: vector.body: -; CHECK: %[[LOAD1:.*]] = load <8 x i32> -; CHECK: %[[LOAD2:.*]] = load <8 x i32> -; CHECK: %[[LOAD3:.*]] = load <8 x i32> -; CHECK: %[[LOAD4:.*]] = load <8 x i32> -; CHECK: %[[ADD1:.*]] = add nsw <8 x i32> %[[LOAD3]], %[[LOAD1]] -; CHECK: %[[ADD2:.*]] = add nsw <8 x i32> %[[LOAD4]], %[[LOAD2]] -; CHECK: %[[MUL1:.*]] = mul <8 x i32> %[[LOAD3]] -; CHECK: %[[MUL2:.*]] = mul <8 x i32> %[[LOAD4]] +; CHECK: %[[LOAD1:.*]] = load <4 x i32> +; CHECK: %[[LOAD2:.*]] = load <4 x i32> +; CHECK: %[[LOAD3:.*]] = load <4 x i32> +; CHECK: %[[LOAD4:.*]] = load <4 x i32> +; CHECK: %[[ADD1:.*]] = add nsw <4 x i32> %[[LOAD3]], %[[LOAD1]] +; CHECK: %[[ADD2:.*]] = add nsw <4 x i32> %[[LOAD4]], %[[LOAD2]] +; CHECK: %[[MUL1:.*]] = mul <4 x i32> %[[LOAD3]] +; CHECK: %[[MUL2:.*]] = mul <4 x i32> %[[LOAD4]] ; CHECK: middle.block: -; CHECK: %[[RDX:.*]] = mul <8 x i32> %[[MUL2]], %[[MUL1]] -; CHECK: call i32 @llvm.vector.reduce.mul.v8i32(<8 x i32> %[[RDX]]) +; CHECK: %[[RDX:.*]] = mul <4 x i32> %[[MUL2]], %[[MUL1]] +; CHECK: call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %[[RDX]]) entry: br label %for.body diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll b/llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll --- a/llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll @@ -39,7 +39,7 @@ ; CHECK-DBG: LV: Max legal vector width too small, scalable vectorization unfeasible. Using fixed-width vectorization instead. ; CHECK-DBG: remark: :0:0: Max legal vector width too small, scalable vectorization unfeasible. Using fixed-width vectorization instead. -; CHECK-DBG: LV: The max safe VF is: 8. +; CHECK-DBG: LV: The max safe fixed VF is: 8. ; CHECK-DBG: LV: Selecting VF: 4. ; CHECK-LABEL: @test1 ; CHECK: <4 x i32> @@ -81,8 +81,8 @@ ; } ; CHECK-DBG: LV: Max legal vector width too small, scalable vectorization unfeasible. Using fixed-width vectorization instead. -; CHECK-DBG: LV: The max safe VF is: 4. -; CHECK-DBG: LV: User VF=8 is unsafe, clamping to max safe VF=4. +; CHECK-DBG: LV: The max safe fixed VF is: 4. +; CHECK-DBG: LV: User VF=vscale x 8 is unsafe, clamping to max safe VF=4. ; CHECK-DBG: LV: Selecting VF: 4. ; CHECK-LABEL: @test2 ; CHECK: <4 x i32> @@ -129,7 +129,7 @@ ; Max fixed VF=32, Max scalable VF=2, safe to vectorize. ; CHECK-DBG-LABEL: LV: Checking a loop in "test3" -; CHECK-DBG: LV: The max safe VF is: vscale x 2. +; CHECK-DBG: LV: The max safe scalable VF is: vscale x 2. ; CHECK-DBG: LV: Using user VF vscale x 2. ; CHECK-LABEL: @test3 ; CHECK: @@ -176,7 +176,7 @@ ; Max fixed VF=32, Max scalable VF=2, unsafe to vectorize. Should clamp to 2. ; CHECK-DBG-LABEL: LV: Checking a loop in "test4" -; CHECK-DBG: LV: The max safe VF is: vscale x 2. +; CHECK-DBG: LV: The max safe scalable VF is: vscale x 2. ; CHECK-DBG: LV: User VF=vscale x 4 is unsafe, clamping to max safe VF=vscale x 2. ; CHECK-DBG: remark: :0:0: User-specified vectorization factor vscale x 4 is unsafe, clamping to maximum safe vectorization factor vscale x 2 ; CHECK-DBG: LV: Using max VF vscale x 2 @@ -225,7 +225,7 @@ ; Max fixed VF=128, Max scalable VF=8, safe to vectorize. ; CHECK-DBG-LABEL: LV: Checking a loop in "test5" -; CHECK-DBG: LV: The max safe VF is: vscale x 8. +; CHECK-DBG: LV: The max safe scalable VF is: vscale x 8. ; CHECK-DBG: LV: Using user VF vscale x 4 ; CHECK-LABEL: @test5 ; CHECK: @@ -271,7 +271,7 @@ ; Max fixed VF=128, Max scalable VF=8, unsafe to vectorize. Should clamp to 8. ; CHECK-DBG-LABEL: LV: Checking a loop in "test6" -; CHECK-DBG: LV: The max safe VF is: vscale x 8. +; CHECK-DBG: LV: The max safe scalable VF is: vscale x 8. ; CHECK-DBG: LV: User VF=vscale x 16 is unsafe, clamping to max safe VF=vscale x 8. ; CHECK-DBG: remark: :0:0: User-specified vectorization factor vscale x 16 is unsafe, clamping to maximum safe vectorization factor vscale x 8 ; CHECK-DBG: LV: Using max VF vscale x 8 @@ -304,8 +304,8 @@ !17 = !{!"llvm.loop.vectorize.scalable.enable", i1 true} ; CHECK-NO-SVE-LABEL: LV: Checking a loop in "test_no_sve" -; CHECK-NO-SVE: LV: Ignoring VF=vscale x 4 because target does not support scalable vectors. -; CHECK-NO-SVE: remark: :0:0: Ignoring VF=vscale x 4 because target does not support scalable vectors. +; CHECK-NO-SVE: LV: Disabling scalable vectorization, because target does not support scalable vectors. +; CHECK-NO-SVE: remark: :0:0: Disabling scalable vectorization, because target does not support scalable vectors. ; CHECK-NO-SVE: LV: Selecting VF: 4. ; CHECK-NO-SVE: <4 x i32> ; CHECK-NO-SVE-NOT: @@ -338,7 +338,7 @@ ; ; CHECK-NO-MAX-VSCALE-LABEL: LV: Checking a loop in "test_no_max_vscale" ; CHECK-NO-MAX-VSCALE: LV: Max legal vector width too small, scalable vectorization unfeasible. Using fixed-width vectorization instead. -; CEHCK-NO-MAX-VSCALE: The max safe VF is: 4. +; CEHCK-NO-MAX-VSCALE: The max safe fixed VF is: 4. ; CHECK-NO-MAX-VSCALE: LV: Selecting VF: 4. ; CHECK-NO-MAX-VSCALE: <4 x i32> define void @test_no_max_vscale(i32* %a, i32* %b) { diff --git a/llvm/test/Transforms/LoopVectorize/scalable-vf-hint.ll b/llvm/test/Transforms/LoopVectorize/scalable-vf-hint.ll --- a/llvm/test/Transforms/LoopVectorize/scalable-vf-hint.ll +++ b/llvm/test/Transforms/LoopVectorize/scalable-vf-hint.ll @@ -3,8 +3,8 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" -; CHECK: LV: Ignoring VF=vscale x 4 because target does not support scalable vectors. -; CHECK: remark: :0:0: Ignoring VF=vscale x 4 because target does not support scalable vectors. +; CHECK: LV: Disabling scalable vectorization, because target does not support scalable vectors. +; CHECK: remark: :0:0: Disabling scalable vectorization, because target does not support scalable vectors. ; CHECK: LV: The Widest register safe to use is: 32 bits. define void @test1(i32* %a, i32* %b) { entry: