[CostModel] Return an invalid cost for memory ops with unsupported types

[kmclaughlin]

Summary

Fixes getTypeConversion to return TypeScalarizeScalableVector when a scalable vector
type cannot be legalized by widening/splitting. When this is the method of legalization
found, getTypeLegalizationCost will return an Invalid cost.

The getMemoryOpCost, getMaskedMemoryOpCost & getGatherScatterOpCost functions already call
getTypeLegalizationCost and will now also return an Invalid cost for unsupported types.

[david-arm]

llvm/include/llvm/Analysis/TargetTransformInfo.h

2261 ↗

(On Diff #345496)

nit: Could you clean up the clang-format warnings?

llvm/lib/CodeGen/TargetLoweringBase.cpp

1019–1020

Hi @kmclaughlin is it possible to add a test for this? For example, just another test for <vscale x 1 x i128>.

[kmclaughlin]

• Changed one of the tests in sve-illegal-types.ll to use <vscale x 1 x i128>
• Ran clang-format

llvm/lib/CodeGen/TargetLoweringBase.cpp

1019–1020

Hi @david-arm, I've changed the @store_nxvi128 test to use vscale x 1 x i128

[david-arm]

LGTM! Thanks for adding the test!

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1183

nit: I think because we bail out at the start of the function if it's not a scalable vector we can actually just do:

VectorType *VTy = cast<ScalableVectorType>(Src);
if (!isLegalToVectorizeElementType(...))

This is also true for getGatherScatterOpCost

[sdesmalen]

llvm/include/llvm/Analysis/TargetTransformInfo.h

1324 ↗

(On Diff #345863)

Does it ever make sense to call this function with VectorIsScalable=false given that fixed-width vectors can fall back on scalarization?
If not, should this then become: isElementTypeLegalForScalableVector(Type *Ty) ?

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1533–1539

nit:

if (!VectorIsScalable)
  return true;
return Ty->isIntegerTy(1) || isLegalElementTypeForSVE(Ty);

[david-arm]

llvm/include/llvm/Analysis/TargetTransformInfo.h

1324 ↗

(On Diff #345863)

I wonder if there may be a possibility in future where a scalable vector supports something that a fixed width one doesn't, e.g. not related specifically to scalarisation?

[sdesmalen]

llvm/include/llvm/Analysis/TargetTransformInfo.h

1324 ↗

(On Diff #345863)

But then I imagine it would still be legal to vectorize, because fixed-width can fall back on scalarization. It would then be up to the cost-model to say which one is more profitable.

[kmclaughlin]

• Renamed isLegalToVectorizeElementType to isElementTypeLegalForScalableVector as suggested by @sdesmalen and stopped passing VectorIsScalable, as we are never calling this function when this is false.

[david-arm]

LGTM! Looks like you've addressed all the review comments!

[sdesmalen]

Hi @kmclaughlin, I'm requesting changes to this patch because after a closer look I believe we can/should rely on the CodeGenerator's information on how to legalize a vector type in order to know how to cost it. The [AArch64]TargetTransformInfo::get*MemoryCost implementations actually already do this. For example, a <vscale x 8 x i32> for SVE will need splitting into 2 x <vscale x 4 x i32>, and so the operation cost would be 2 x the cost of a memory operation on a legal type. For scalable vector types that need scalarization, we know the cost is Invalid, because the code-generator is unable to handle these types. In practice, this requires:

• Fixing getTypeConversion to return TypeScalarizeScalableVector when a scalable vector type cannot be legalized by widening/splitting.
• Returning an Invalid cost from getTypeLegalizationCost when the method of legalization is TypeScalarizeScalableVector.
• In the AArch64TTI methods that return the cost of memory operations, we already call getTypeLegalizationCost, so all that needs doing is returning Invalid.

The method isElementTypeLegalForScalableVector is more something to add in D102253 where it is called by the LV before it has picked a VF, to know if there is any VF which can handle these types. If so, then it must be possible to legalize the types by splitting or widening and so the CostModel must be able to cost them.

llvm/lib/CodeGen/TargetLoweringBase.cpp

1019–1020

This comment will become redundant when you address my other comment, but I found that when removing this change, the tests still passed because the calls to isElementTypeLegalForScalableVector return before calling the getTypeLegalizationCost code (which ends up in this function).

[kmclaughlin]

• Removed isElementTypeLegalForScalableVector from this patch
• Changed getTypeConversion to return TypeScalarizeScalableVector if a scalable type cannot be legalized by widening/splitting.
• Return an Invalid cost from getMemoryOpCost, getMaskedMemoryOpCost & getGatherScatterOpCost if the cost returned by getTypeLegalizationCost is Invalid

[dfukalov]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

My observation was that here less destructive for test is to just Cost.setInvalid() instead of return 'empty' invalid value. So the function continues to return the same numeric value but with invalid flag. It will create less impact on the current flow.

Most of operations with InstructionCost are not aware of invalid flag. I guess it might be be next separated step to stop loop here and just return invalid value and then gather all side effects of 'changed' cost numeric value.

Btw my D102915, D103407 and D103406 are preparation to return invalid cost flag from the function and to reduce impact of the change.

[kmclaughlin]

• Changed getTypeConversion to only set the cost to Invalid for TypeScalarizeScalableVector
• Removed a failing test in AArch64SelectionDAGTest.cpp testing the "Cannot legalize this vector" assert, which has been removed.
• Removed the CHECK-NO-MAX-VSCALE RUN line from scalable-vf-hint.ll. This line used the -force-target-supports-scalable-vectors=true flag but did not enable +sve, resulting in an Invalid cost being returning in getRegUsage.

[kmclaughlin]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

Hi @dfukalov, thanks for the suggestion. I have updated this to instead set the cost to Invalid where the kind is TypeScalarizeScalableVector for now.

[sdesmalen]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

The value of Invalid is irrelevant when the Invalid flag is set. In fact, retrieving the value is not possible since InstructionCost::getValue() returns an llvm::Optional. Because there is nothing the code below can do to change the invalid cost to a valid cost, there's no reason not to break out of the loop early by returning std::make_pair(InstructionCost::getInvalid(), ..).

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1183

nit: I'd prefer for this to be written as:

if (!LT.first.isValid())
  return InstructionCost::getInvalid();
return LT.first * 2;

so it's a little more explicit that Invalid is returned.

llvm/test/Analysis/CostModel/AArch64/sve-illegal-types.ll

4

Can you structure these tests a bit more so that we check the code in TargetLoweringBase for each of the types:

nxv1i128
nxv2i128
nxv1f128
nxv2f128

using e.g. load, and then testing all the other load/store operations (store, masked.load, masked.store) with only nxv1i128.

You can also merge all the instructions into the same function, because for invoking the cost-model, it doesn't actually matter how the result values are used.

llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll

5

Is it necessary to pipe the output to a temporary file and use a different check-prefix?

[dfukalov]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

Actually almost all operations on InstructionCost ignore invalid flag at the moment. I don't insist, just suggested to split the changes to smaller steps to reduce future side effects of a commit.

[sdesmalen]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

Perhaps I misunderstand your concern, do you mean that if InstructionCost has a value like "10" but the value has been set to 'Invalid', that the original code which called getTypeLegalizationCost will continue to operate on the value "10"? That's not really how InstructionCost works, once the value is Invalid, it will never become Valid. i.e. Invalid * 2 is still Invalid. It's also not possible to retrieve the original value "10", because InstructionCost::getValue() returns an Optional, which if the cost is Invalid, will be None.

So even if most operations on InstructionCost are not aware of the Invalid flag, they mostly just continue propagating "invalid", and this will eventually bubble up to top-level call where it needs to do somethign with the value (e.g. by calling 'getValue()''). These instances should already be able to deal with Invalid, and if it does cause a crash, then this is something we'll need to fix.

At the moment though, the only case where this patch may have an impact are with scalable vectors in combination with illegal vectors. This combination is still very experimental, so if this does end up breaking anything it just highlights something that needs fixing.

[dfukalov]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

There are a lot of places where logic is based on comparison of InstructionCost with an integer or at least between two costs. In D103406 I experimented and renamed getValue() - it's used in a few dozens places.
It seems all other code (like comparisons and arithmetic operations) still ignore invalid flag. It will be next, I guess painful, step to check invalid (and assert?) at least in comparison with integers.

As an illustration of the impact, you can check test report of the previous patch version. I don't know how many regressions will be in cases not covered with tests.

Again, I don't insist, but it seems to me if a cost model change with unpredicted regressions can be splitted to smaller patches - it would be better to split it.

[sdesmalen]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

There are a lot of places where logic is based on comparison of InstructionCost with an integer or at least between two costs. In D103406 I experimented and renamed getValue() - it's used in a few dozens places.
It seems all other code (like comparisons and arithmetic operations) still ignore invalid flag. It will be next, I guess painful, step to check invalid (and assert?) at least in comparison with integers.

InstructionCost has overloaded comparison- and arithmetic operators. The comparison operators check the Invalid flag. e.g. for some auto X = InstructionCost::(42).setInvalid();, then (X == 42) <=> false. See the implementation here: https://github.com/llvm/llvm-project/blob/d480f968ad8b56d3ee4a6b6df5532d485b0ad01e/llvm/include/llvm/Support/InstructionCost.h#L169 .

The arithmetic operators propagate the Invalid flag, so that X.isValid() == (X * 2).isValid().

As an illustration of the impact, you can check test report of the previous patch version. I don't know how many regressions will be in cases not covered with tests.

@kmclaughlin explained to me off-list that these tests needed fixing in the previous revision of the patch, and so with the current patch the tests should still pass when changing the code back to return InstructionCost::getInvalid().

Thanks for raising these concerns, it's good to check we're not missing anything. But I hope the above explains why it should be safe to return getInvalid() directly.

[kmclaughlin]

• Changed getTypeConversion back to return an invalid cost for TypeScalarizeScalableVector.
• Added tests for loads of nxv1i128, nxv2i128, nxv1f128 & nxv2f128 to sve-illegal-types.ll & grouped the instructions into fewer functions.
• Moved a failing test from test/Transforms/VectorCombine/X86/extract-cmp-binop.ll. This test uses scalable vectors and will fail in X86TTIImpl::getVectorInstrCost with the changes in this patch.

[kmclaughlin]

llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll

5

I tried changing all CHECK-NO-MAX-VSCALEs to CHECK-NO-SVE, but this caused the test to fail. I think something like this is needed so that @test_no_sve and @test_no_max_vscale can have CHECK lines for both the output from -loop-vectorize and -pass-remarks-analysis=loop-vectorize.
I could instead add another RUN line, similar to the other tests which use the CHECK & CHECK-DBG prefixes?

[sdesmalen]

Just one final request about one of the tests, but otherwise the patch looks good to me.

llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp

576

Instead of removing the test, can you instead check that the TypeAction is ScalarizeScalableVector?

[kmclaughlin]

• Added a test to AArch64SelectionDAGTest.cpp which checks that getTypeAction returns TypeScalarizeScalableVector for an illegal type

[dfukalov]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

InstructionCost has overloaded comparison- and arithmetic operators. The comparison operators check the Invalid flag. e.g. for some auto X = InstructionCost::(42).setInvalid();, then (X == 42) <=> false.

Yes. But at the same time for some auto X = InstructionCost::(42).setInvalid(); we have funny X > 142 <=> true, since it finally calls InstructionCost(142).operator<(X) that has if (State != RHS.State) return State < RHS.State; at the start. I guess there are a lot of places with "cost > threshold" comparisons.
It seems we need to fix InstructionCost comparisons (and other operations?) before the change or we'll get side effects.

Actually I thought any operation with invalid cost should cause assert at some point in beautiful future. Am I right it was intended?

[sdesmalen]

llvm/lib/CodeGen/TargetLoweringBase.cpp

1848–1850

Yes. But at the same time for some auto X = InstructionCost::(42).setInvalid(); we have funny X > 142 <=> true, since it finally calls InstructionCost(142).operator<(X) that has if (State != RHS.State) return State < RHS.State; at the start. I guess there are a lot of places with "cost > threshold" comparisons.

That's actually a feature, not a bug :) We basically had the option of always asserting that both costs need to be valid (which would lead to lots of extra code to always guarantee this by checking X.isValid() && Y.isValid() in lots of places before being able to compare the two costs. The other option was to have a documented total ordering where Invalid is considered 'infinitely expensive' when compared with any other costs. This is useful, because in most places the comparison is there to check if the cost of "some operation" is an improvement over the cost of some other operation. And an Invalid cost can never be an improvement to a valid cost.

It seems we need to fix InstructionCost comparisons (and other operations?) before the change or we'll get side effects.

Most places have already been fixed in the passes that use InstructionCost. Perhaps there are some cases we've missed, but hopefully these show up easily enough in our testing. I expect most of these cases are actually gaps in our cost-model for scalable vectors, which is currently the only reason we ever return Invalid. For fixed-width vectors or anything else, we should always have valid costs.

[sdesmalen]

LGTM, thanks @kmclaughlin

llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp

577

nit: ElementCount::getScalable(1) is a bit more readable.

579

nit: It's better to test the result explicitly, i.e.:

EXPECT_EQ(getTypeToTransformTo(VT) == MVT::f128);

llvm/lib/CodeGen/TargetLoweringBase.cpp

if (EltVT.isInteger()) {
     }
 
     // Examine the element type.
     LegalizeKind LK = getTypeConversion(Context, EltVT);
 
     // If type is to be expanded, split the vector.
     //  <4 x i140> -> <2 x i140>
     if (LK.first == TypeExpandInteger) {
-      if (VT.getVectorElementCount() == ElementCount::getScalable(1))
-        report_fatal_error("Cannot legalize this scalable vector");
+      if (VT.getVectorElementCount().isScalable())
+        return LegalizeKind(TypeScalarizeScalableVector, EltVT);
       return LegalizeKind(TypeSplitVector,
                           VT.getHalfNumVectorElementsVT(Context));
     }
 
     // Promote the integer element types until a legal vector type is found
     // or until the element integer type is too big. If a legal type was not
     // found, fallback to the usual mechanism of widening/splitting the
     // vector.
TargetLoweringBase::getTypeConversion(LLVMContext &Context, EVT VT) const {
 
   // Widen odd vectors to next power of two.
   if (!VT.isPow2VectorType()) {
     EVT NVT = VT.getPow2VectorType(Context);
     return LegalizeKind(TypeWidenVector, NVT);
   }
 
   if (VT.getVectorElementCount() == ElementCount::getScalable(1))
-    report_fatal_error("Cannot legalize this vector");
+    return LegalizeKind(TypeScalarizeScalableVector, EltVT);
 
   // Vectors with illegal element types are expanded.
   EVT NVT = EVT::getVectorVT(Context, EltVT,
                              VT.getVectorElementCount().divideCoefficientBy(2));
   return LegalizeKind(TypeSplitVector, NVT);
 }
 
 static unsigned getVectorTypeBreakdownMVT(MVT VT, MVT &IntermediateVT,
TargetLoweringBase::getTypeLegalizationCost(const DataLayout &DL,
 
   InstructionCost Cost = 1;
   // We keep legalizing the type until we find a legal kind. We assume that
   // the only operation that costs anything is the split. After splitting
   // we need to handle two types.
   while (true) {
     LegalizeKind LK = getTypeConversion(C, MTy);
 
+    if (LK.first == TypeScalarizeScalableVector)
+      return std::make_pair(InstructionCost::getInvalid(), MVT::getVT(Ty));
+
     if (LK.first == TypeLegal)
       return std::make_pair(Cost, MTy.getSimpleVT());
 
     if (LK.first == TypeSplitVector || LK.first == TypeExpandInteger)
       Cost *= 2;
 
     // Do not loop with f128 type.
     if (MTy == LK.second)

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

 InstructionCost
 AArch64TTIImpl::getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
                                       Align Alignment, unsigned AddressSpace,
                                       TTI::TargetCostKind CostKind) {
   if (!isa<ScalableVectorType>(Src))
     return BaseT::getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
                                         CostKind);
   auto LT = TLI->getTypeLegalizationCost(DL, Src);
+  if (!LT.first.isValid())
+    return InstructionCost::getInvalid();
   return LT.first * 2;
 }
 
 InstructionCost AArch64TTIImpl::getGatherScatterOpCost(
     unsigned Opcode, Type *DataTy, const Value *Ptr, bool VariableMask,
     Align Alignment, TTI::TargetCostKind CostKind, const Instruction *I) {
 
   if (!isa<ScalableVectorType>(DataTy))
     return BaseT::getGatherScatterOpCost(Opcode, DataTy, Ptr, VariableMask,
                                          Alignment, CostKind, I);
   auto *VT = cast<VectorType>(DataTy);
   auto LT = TLI->getTypeLegalizationCost(DL, DataTy);
+  if (!LT.first.isValid())
+    return InstructionCost::getInvalid();
+
   ElementCount LegalVF = LT.second.getVectorElementCount();
   Optional<unsigned> MaxNumVScale = getMaxVScale();
   assert(MaxNumVScale && "Expected valid max vscale value");
 
   InstructionCost MemOpCost =
       getMemoryOpCost(Opcode, VT->getElementType(), Alignment, 0, CostKind, I);
   unsigned MaxNumElementsPerGather =
       MaxNumVScale.getValue() * LegalVF.getKnownMinValue();
InstructionCost AArch64TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Ty,
                                                 TTI::TargetCostKind CostKind,
                                                 const Instruction *I) {
   // Type legalization can't handle structs
   if (TLI->getValueType(DL, Ty,  true) == MVT::Other)
     return BaseT::getMemoryOpCost(Opcode, Ty, Alignment, AddressSpace,
                                   CostKind);
 
   auto LT = TLI->getTypeLegalizationCost(DL, Ty);
+  if (!LT.first.isValid())
+    return InstructionCost::getInvalid();
 
   // TODO: consider latency as well for TCK_SizeAndLatency.
   if (CostKind == TTI::TCK_CodeSize || CostKind == TTI::TCK_SizeAndLatency)
     return LT.first;
 
   if (CostKind != TTI::TCK_RecipThroughput)
     return 1;
 
if (const GetElementPtrInst *GEPInst = dyn_cast<GetElementPtrInst>(U)) {
       }
     }
   }
   return Considerable;
 }
 
 bool AArch64TTIImpl::isLegalToVectorizeReduction(RecurrenceDescriptor RdxDesc,
                                                  ElementCount VF) const {
   if (!VF.isScalable())
     return true;
 
   Type *Ty = RdxDesc.getRecurrenceType();
   if (Ty->isBFloatTy() || !isLegalElementTypeForSVE(Ty))
     return false;
 
   switch (RdxDesc.getRecurrenceKind()) {
   case RecurKind::Add:
   case RecurKind::FAdd:
   case RecurKind::And:
   case RecurKind::Or:
   case RecurKind::Xor:
   case RecurKind::SMin:
   case RecurKind::SMax:

llvm/test/Analysis/CostModel/AArch64/sve-illegal-types.ll

+; RUN: opt -cost-model -analyze -mtriple=aarch64--linux-gnu -mattr=+sve  < %s | FileCheck %s
+
+define void @load_store(<vscale x 1 x i128>* %ptrs) {
+; CHECK-LABEL: 'load_store'
+; CHECK-NEXT: Invalid cost for instruction: %load1 = load <vscale x 1 x i128>, <vscale x 1 x i128>* undef
+; CHECK-NEXT: Invalid cost for instruction: %load2 = load <vscale x 2 x i128>, <vscale x 2 x i128>* undef
+; CHECK-NEXT: Invalid cost for instruction: %load3 = load <vscale x 1 x fp128>, <vscale x 1 x fp128>* undef
+; CHECK-NEXT: Invalid cost for instruction: %load4 = load <vscale x 2 x fp128>, <vscale x 2 x fp128>* undef
+; CHECK-NEXT: Invalid cost for instruction: store <vscale x 1 x i128> %load1, <vscale x 1 x i128>* %ptrs
+  %load1 = load <vscale x 1 x i128>, <vscale x 1 x i128>* undef
+  %load2 = load <vscale x 2 x i128>, <vscale x 2 x i128>* undef
+  %load3 = load <vscale x 1 x fp128>, <vscale x 1 x fp128>* undef
+  %load4 = load <vscale x 2 x fp128>, <vscale x 2 x fp128>* undef
+  store <vscale x 1 x i128> %load1, <vscale x 1 x i128>* %ptrs
+  ret void
+}
+
+define void @masked_load_store(<vscale x 1 x i128>* %ptrs, <vscale x 1 x i128>* %val, <vscale x 1 x i1> %mask, <vscale x 1 x i128> %passthru) {
+; CHECK-LABEL: 'masked_load_store'
+; CHECK-NEXT: Invalid cost for instruction: %mload = call <vscale x 1 x i128> @llvm.masked.load.nxv1i128.p0nxv1i128(<vscale x 1 x i128>* %val, i32 8, <vscale x 1 x i1> %mask, <vscale x 1 x i128> %passthru)
+; CHECK-NEXT: Invalid cost for instruction: call void @llvm.masked.store.nxv1i128.p0nxv1i128(<vscale x 1 x i128> %mload, <vscale x 1 x i128>* %ptrs, i32 8, <vscale x 1 x i1> %mask)
+  %mload = call <vscale x 1 x i128> @llvm.masked.load.nxv1i128(<vscale x 1 x i128>* %val, i32 8, <vscale x 1 x i1> %mask, <vscale x 1 x i128> %passthru)
+  call void @llvm.masked.store.nxv1i128(<vscale x 1 x i128> %mload, <vscale x 1 x i128>* %ptrs, i32 8, <vscale x 1 x i1> %mask)
+  ret void
+}
+
+define void @masked_gather_scatter(<vscale x 1 x i128*> %ptrs, <vscale x 1 x i128*> %val, <vscale x 1 x i1> %mask, <vscale x 1 x i128> %passthru) {
+; CHECK-LABEL: 'masked_gather_scatter'
+; CHECK-NEXT: Invalid cost for instruction: %mgather = call <vscale x 1 x i128> @llvm.masked.gather.nxv1i128.nxv1p0i128(<vscale x 1 x i128*> %val, i32 0, <vscale x 1 x i1> %mask, <vscale x 1 x i128> %passthru)
+; CHECK-NEXT: Invalid cost for instruction: call void @llvm.masked.scatter.nxv1i128.nxv1p0i128(<vscale x 1 x i128> %mgather, <vscale x 1 x i128*> %ptrs, i32 0, <vscale x 1 x i1> %mask)
+  %mgather = call <vscale x 1 x i128> @llvm.masked.gather.nxv1i128(<vscale x 1 x i128*> %val, i32 0, <vscale x 1 x i1> %mask, <vscale x 1 x i128> %passthru)
+  call void @llvm.masked.scatter.nxv1i128(<vscale x 1 x i128> %mgather, <vscale x 1 x i128*> %ptrs, i32 0, <vscale x 1 x i1> %mask)
+  ret void
+}
+
+declare <vscale x 1 x i128> @llvm.masked.load.nxv1i128(<vscale x 1 x i128>*, i32, <vscale x 1 x i1>, <vscale x 1 x i128>)
+declare <vscale x 1 x i128> @llvm.masked.gather.nxv1i128(<vscale x 1 x i128*>, i32, <vscale x 1 x i1>, <vscale x 1 x i128>)
+
+declare void @llvm.masked.store.nxv1i128(<vscale x 1 x i128>, <vscale x 1 x i128>*, i32, <vscale x 1 x i1>)
+declare void @llvm.masked.scatter.nxv1i128(<vscale x 1 x i128>, <vscale x 1 x i128*>, i32, <vscale x 1 x i1>)

llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll

 ; REQUIRES: asserts
 ; RUN: opt -mtriple=aarch64-none-linux-gnu -mattr=+sve -loop-vectorize -S -scalable-vectorization=on < %s 2>&1 | FileCheck %s
 ; RUN: opt -mtriple=aarch64-none-linux-gnu -mattr=+sve -loop-vectorize -pass-remarks-analysis=loop-vectorize -debug-only=loop-vectorize -S -scalable-vectorization=on < %s 2>&1 | FileCheck --check-prefix=CHECK-DBG %s
-; RUN: opt -mtriple=aarch64-none-linux-gnu -loop-vectorize -pass-remarks-analysis=loop-vectorize -debug-only=loop-vectorize -S -scalable-vectorization=on < %s 2>&1 | FileCheck --check-prefix=CHECK-NO-SVE %s
-; RUN: opt -mtriple=aarch64-none-linux-gnu -loop-vectorize -force-target-supports-scalable-vectors=true -pass-remarks-analysis=loop-vectorize -debug-only=loop-vectorize -S -scalable-vectorization=on < %s 2>&1 | FileCheck --check-prefix=CHECK-NO-MAX-VSCALE %s
+; RUN: opt -mtriple=aarch64-none-linux-gnu -loop-vectorize -pass-remarks-analysis=loop-vectorize -debug-only=loop-vectorize -S -scalable-vectorization=on < %s 2>%t | FileCheck --check-prefix=CHECK-NO-SVE %s
+; RUN: cat %t | FileCheck %s -check-prefix=CHECK-NO-SVE-REMARKS
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 ; These tests validate the behaviour of scalable vectorization factor hints,
 ; where the following applies:
 ;
 ; * If the backend does not support scalable vectors, ignore the hint and let
 ;   the vectorizer pick a VF.

 exit:
   ret void
 }
 
 !15 = !{!15, !16, !17}
 !16 = !{!"llvm.loop.vectorize.width", i32 16}
 !17 = !{!"llvm.loop.vectorize.scalable.enable", i1 true}
 
-; CHECK-NO-SVE-LABEL: LV: Checking a loop in "test_no_sve"
-; CHECK-NO-SVE: LV: Disabling scalable vectorization, because target does not support scalable vectors.
-; CHECK-NO-SVE: remark: <unknown>:0:0: Disabling scalable vectorization, because target does not support scalable vectors.
-; CHECK-NO-SVE: LV: User VF=vscale x 4 is unsafe. Ignoring scalable UserVF.
-; CHECK-NO-SVE: LV: Selecting VF: 4.
+; CHECK-NO-SVE-REMARKS-LABEL: LV: Checking a loop in "test_no_sve"
+; CHECK-NO-SVE-REMARKS: LV: Disabling scalable vectorization, because target does not support scalable vectors.
+; CHECK-NO-SVE-REMARKS: remark: <unknown>:0:0: Disabling scalable vectorization, because target does not support scalable vectors.
+; CHECK-NO-SVE-REMARKS: LV: User VF=vscale x 4 is unsafe. Ignoring scalable UserVF.
+; CHECK-NO-SVE-REMARKS: LV: Selecting VF: 4.
+; CHECK-NO-SVE-LABEL: @test_no_sve
 ; CHECK-NO-SVE: <4 x i32>
 ; CHECK-NO-SVE-NOT: <vscale x 4 x i32>
 define void @test_no_sve(i32* %a, i32* %b) {
 entry:
   br label %loop
 
 loop:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]

 
 !18 = !{!18, !19, !20}
 !19 = !{!"llvm.loop.vectorize.width", i32 4}
 !20 = !{!"llvm.loop.vectorize.scalable.enable", i1 true}
 
 ; Test the LV falls back to fixed-width vectorization if scalable vectors are
 ; supported but max vscale is undefined.
 ;
-; CHECK-NO-MAX-VSCALE-LABEL: LV: Checking a loop in "test_no_max_vscale"
-; CEHCK-NO-MAX-VSCALE: The max safe fixed VF is: 4.
-; CHECK-NO-MAX-VSCALE: LV: User VF=vscale x 4 is unsafe. Ignoring scalable UserVF.
-; CHECK-NO-MAX-VSCALE: LV: Selecting VF: 4.
-; CHECK-NO-MAX-VSCALE: <4 x i32>
+; CHECK-NO-SVE-REMARKS-LABEL: LV: Checking a loop in "test_no_max_vscale"
+; CHECK-NO-SVE-REMARKS: The max safe fixed VF is: 4.
+; CHECK-NO-SVE-REMARKS: LV: User VF=vscale x 4 is unsafe. Ignoring scalable UserVF.
+; CHECK-NO-SVE-REMARKS: LV: Selecting VF: 4.
+; CHECK-NO-SVE-LABEL: @test_no_max_vscale
+; CHECK-NO-SVE: <4 x i32>
 define void @test_no_max_vscale(i32* %a, i32* %b) {
 entry:
   br label %loop
 
 loop:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
   %arrayidx = getelementptr inbounds i32, i32* %a, i64 %iv
   %0 = load i32, i32* %arrayidx, align 4

llvm/test/Transforms/VectorCombine/AArch64/extract-cmp-binop.ll

+; RUN: opt -vector-combine -S %s | FileCheck %s
+
+; Negative test for extract + cmp + binop - don't try this with scalable vectors.
+; Moved from X86/extract-cmp-binop.ll
+
+define i1 @scalable(<vscale x 4 x i32> %a) {
+; CHECK-LABEL: @scalable(
+; CHECK-NEXT:    [[E1:%.*]] = extractelement <vscale x 4 x i32> [[A:%.*]], i32 3
+; CHECK-NEXT:    [[E2:%.*]] = extractelement <vscale x 4 x i32> [[A]], i32 1
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i32 [[E1]], 42
+; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i32 [[E2]], -8
+; CHECK-NEXT:    [[R:%.*]] = xor i1 [[CMP1]], [[CMP2]]
+; CHECK-NEXT:    ret i1 [[R]]
+;
+  %e1 = extractelement <vscale x 4 x i32> %a, i32 3
+  %e2 = extractelement <vscale x 4 x i32> %a, i32 1
+  %cmp1 = icmp sgt i32 %e1, 42
+  %cmp2 = icmp sgt i32 %e2, -8
+  %r = xor i1 %cmp1, %cmp2
+  ret i1 %r
+}

llvm/test/Transforms/VectorCombine/X86/extract-cmp-binop.ll

 ;
   %e1 = extractelement <4 x i32> %a, i32 1
   %e2 = extractelement <4 x i32> %b, i32 2
   %cmp1 = icmp sgt i32 %e1, 42
   %cmp2 = icmp sgt i32 %e2, -8
   %r = and i1 %cmp1, %cmp2
   ret i1 %r
 }
-
-; Negative test - don't try this with scalable vectors.
-
-define i1 @scalable(<vscale x 4 x i32> %a) {
-; CHECK-LABEL: @scalable(
-; CHECK-NEXT:    [[E1:%.*]] = extractelement <vscale x 4 x i32> [[A:%.*]], i32 3
-; CHECK-NEXT:    [[E2:%.*]] = extractelement <vscale x 4 x i32> [[A]], i32 1
-; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i32 [[E1]], 42
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i32 [[E2]], -8
-; CHECK-NEXT:    [[R:%.*]] = xor i1 [[CMP1]], [[CMP2]]
-; CHECK-NEXT:    ret i1 [[R]]
-;
-  %e1 = extractelement <vscale x 4 x i32> %a, i32 3
-  %e2 = extractelement <vscale x 4 x i32> %a, i32 1
-  %cmp1 = icmp sgt i32 %e1, 42
-  %cmp2 = icmp sgt i32 %e2, -8
-  %r = xor i1 %cmp1, %cmp2
-  ret i1 %r
-}

llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp

 TEST_F(AArch64SelectionDAGTest, getTypeConversion_WidenScalableEVT) {
   EVT FromVT = EVT::getVectorVT(Context, MVT::i64, 6, true);
   EVT ToVT = EVT::getVectorVT(Context, MVT::i64, 8, true);
 
   EXPECT_EQ(getTypeAction(FromVT), TargetLoweringBase::TypeWidenVector);
   EXPECT_EQ(getTypeToTransformTo(FromVT), ToVT);
 }
 
-TEST_F(AArch64SelectionDAGTest, getTypeConversion_NoScalarizeEVT_nxv1f128) {
-  EVT FromVT = EVT::getVectorVT(Context, MVT::f128, 1, true);
-  EXPECT_DEATH(getTypeAction(FromVT), "Cannot legalize this vector");
+TEST_F(AArch64SelectionDAGTest, getTypeConversion_ScalarizeScalableEVT_nxv1f128) {
+  EVT VT = EVT::getVectorVT(Context, MVT::f128, 1, true);
+  EXPECT_EQ(getTypeAction(VT), TargetLoweringBase::TypeScalarizeScalableVector);
+  ASSERT_FALSE(getTypeToTransformTo(VT).isScalableVector());
 }
 
 TEST_F(AArch64SelectionDAGTest, TestFold_STEP_VECTOR) {
   SDLoc Loc;
   auto IntVT = EVT::getIntegerVT(Context, 8);
   auto VecVT = EVT::getVectorVT(Context, MVT::i8, 16, true);
 
   // Should create SPLAT_VECTOR
   SDValue Zero = DAG->getConstant(0, Loc, IntVT);
   SDValue Op = DAG->getNode(ISD::STEP_VECTOR, Loc, VecVT, Zero);
   EXPECT_EQ(Op.getOpcode(), ISD::SPLAT_VECTOR);
 }
 
 } // end namespace llvm