Index: llvm/lib/CodeGen/TargetLoweringBase.cpp
===================================================================
--- llvm/lib/CodeGen/TargetLoweringBase.cpp
+++ llvm/lib/CodeGen/TargetLoweringBase.cpp
@@ -1016,8 +1016,8 @@
     // 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));
     }
@@ -1080,7 +1080,7 @@
   }
 
   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,
@@ -1845,6 +1845,9 @@
   while (true) {
     LegalizeKind LK = getTypeConversion(C, MTy);
 
+    if (LK.first == TypeScalarizeScalableVector)
+      Cost.setInvalid();
+
     if (LK.first == TypeLegal)
       return std::make_pair(Cost, MTy.getSimpleVT());
 
Index: llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
===================================================================
--- llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
+++ llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
@@ -1180,6 +1180,9 @@
     return BaseT::getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
                                         CostKind);
   auto LT = TLI->getTypeLegalizationCost(DL, Src);
+  if (!LT.first.isValid())
+    return LT.first;
+
   return LT.first * 2;
 }
 
@@ -1192,6 +1195,9 @@
                                          Alignment, CostKind, I);
   auto *VT = cast<VectorType>(DataTy);
   auto LT = TLI->getTypeLegalizationCost(DL, DataTy);
+  if (!LT.first.isValid())
+    return LT.first;
+
   ElementCount LegalVF = LT.second.getVectorElementCount();
   Optional<unsigned> MaxNumVScale = getMaxVScale();
   assert(MaxNumVScale && "Expected valid max vscale value");
@@ -1218,6 +1224,8 @@
                                   CostKind);
 
   auto LT = TLI->getTypeLegalizationCost(DL, Ty);
+  if (!LT.first.isValid())
+    return LT.first;
 
   // TODO: consider latency as well for TCK_SizeAndLatency.
   if (CostKind == TTI::TCK_CodeSize || CostKind == TTI::TCK_SizeAndLatency)
Index: llvm/test/Analysis/CostModel/AArch64/sve-illegal-types.ll
===================================================================
--- /dev/null
+++ llvm/test/Analysis/CostModel/AArch64/sve-illegal-types.ll
@@ -0,0 +1,49 @@
+; RUN: opt -cost-model -analyze -mtriple=aarch64--linux-gnu -mattr=+sve  < %s | FileCheck %s
+
+define <vscale x 2 x i128> @load_nxvi128(<vscale x 2 x i128>* %val) {
+; CHECK-LABEL: 'load_nxvi128'
+; CHECK-NEXT: Invalid cost for instruction: %load = load <vscale x 2 x i128>, <vscale x 2 x i128>* %val
+  %load = load <vscale x 2 x i128>, <vscale x 2 x i128>* %val
+  ret <vscale x 2 x i128> %load
+}
+
+define void @store_nxvi128(<vscale x 1 x i128>* %ptrs, <vscale x 1 x i128> %val) {
+; CHECK-LABEL: 'store_nxvi128'
+; CHECK-NEXT: Invalid cost for instruction: store <vscale x 1 x i128> %val, <vscale x 1 x i128>* %ptrs
+  store <vscale x 1 x i128> %val, <vscale x 1 x i128>* %ptrs
+  ret void
+}
+
+define <vscale x 4 x fp128> @masked_load_nxvfp128(<vscale x 4 x fp128>* %val, <vscale x 4 x i1> %mask, <vscale x 4 x fp128> %passthru) {
+; CHECK-LABEL: 'masked_load_nxvfp128'
+; CHECK-NEXT: Invalid cost for instruction: %mload = call <vscale x 4 x fp128> @llvm.masked.load.nxv4f128.p0nxv4f128(<vscale x 4 x fp128>* %val, i32 8, <vscale x 4 x i1> %mask, <vscale x 4 x fp128> %passthru)
+  %mload = call <vscale x 4 x fp128> @llvm.masked.load.nxv4f128(<vscale x 4 x fp128>* %val, i32 8, <vscale x 4 x i1> %mask, <vscale x 4 x fp128> %passthru)
+  ret <vscale x 4 x fp128> %mload
+}
+
+define void @masked_store_nxvfp128(<vscale x 4 x fp128> %val, <vscale x 4 x fp128>* %ptrs, <vscale x 4 x i1> %mask) {
+; CHECK-LABEL: 'masked_store_nxvfp128'
+; CHECK-NEXT: Invalid cost for instruction: call void @llvm.masked.store.nxv4f128.p0nxv4f128(<vscale x 4 x fp128> %val, <vscale x 4 x fp128>* %ptrs, i32 8, <vscale x 4 x i1> %mask)
+  call void @llvm.masked.store.nxv4f128(<vscale x 4 x fp128> %val, <vscale x 4 x fp128>* %ptrs, i32 8, <vscale x 4 x i1> %mask)
+  ret void
+}
+
+define <vscale x 2 x i128> @masked_gather_nxv2i128(<vscale x 2 x i128*> %ld, <vscale x 2 x i1> %masks, <vscale x 2 x i128> %passthru) {
+; CHECK-LABEL: 'masked_gather_nxv2i128'
+; CHECK-NEXT: Invalid cost for instruction: %mgather = call <vscale x 2 x i128> @llvm.masked.gather.nxv2i128.nxv2p0i128(<vscale x 2 x i128*> %ld, i32 0, <vscale x 2 x i1> %masks, <vscale x 2 x i128> %passthru)
+  %mgather = call <vscale x 2 x i128> @llvm.masked.gather.nxv2i128(<vscale x 2 x i128*> %ld, i32 0, <vscale x 2 x i1> %masks, <vscale x 2 x i128> %passthru)
+  ret <vscale x 2 x i128> %mgather
+}
+
+define void @masked_scatter_nxv4i128(<vscale x 4 x i128> %val, <vscale x 4 x i128*> %ptrs, <vscale x 4 x i1> %masks) {
+; CHECK-LABEL: 'masked_scatter_nxv4i128'
+; CHECK-NEXT: Invalid cost for instruction: call void @llvm.masked.scatter.nxv4i128.nxv4p0i128(<vscale x 4 x i128> %val, <vscale x 4 x i128*> %ptrs, i32 0, <vscale x 4 x i1> %masks)
+  call void @llvm.masked.scatter.nxv4i128(<vscale x 4 x i128> %val, <vscale x 4 x i128*> %ptrs, i32 0, <vscale x 4 x i1> %masks)
+  ret void
+}
+
+declare <vscale x 4 x fp128> @llvm.masked.load.nxv4f128(<vscale x 4 x fp128>*, i32, <vscale x 4 x i1>, <vscale x 4 x fp128>)
+declare <vscale x 2 x i128> @llvm.masked.gather.nxv2i128(<vscale x 2 x i128*>, i32, <vscale x 2 x i1>, <vscale x 2 x i128>)
+
+declare void @llvm.masked.store.nxv4f128(<vscale x 4 x fp128>, <vscale x 4 x fp128>*, i32, <vscale x 4 x i1>)
+declare void @llvm.masked.scatter.nxv4i128(<vscale x 4 x i128>, <vscale x 4 x i128*>, i32, <vscale x 4 x i1>)
Index: llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll
===================================================================
--- llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll
+++ llvm/test/Transforms/LoopVectorize/AArch64/scalable-vf-hint.ll
@@ -1,8 +1,8 @@
 ; 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"
 
@@ -309,11 +309,12 @@
 !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) {
@@ -343,11 +344,12 @@
 ; 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
Index: llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
===================================================================
--- llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
+++ llvm/unittests/CodeGen/AArch64SelectionDAGTest.cpp
@@ -573,11 +573,6 @@
   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, TestFold_STEP_VECTOR) {
   SDLoc Loc;
   auto IntVT = EVT::getIntegerVT(Context, 8);