[clang][CodeGen] Add noundef metadata to loading of vector/matrix lvalues (preliminary 4 or 5)

[jmciver]

Summary

Add noundef attribute support when an rvalue is being stored into a vector/matrix lvalue.

[jmciver]

Updating D139378: [clang][CodeGen] Add noundef metadata to load instructions (preliminary 4 or 4)

Update vector-noundef.cpp with rvalue element being stored in lvalue vector.

clang/lib/CodeGen/CGExpr.cpp

 /// is 'Ty'.
 void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
                                              bool isInit) {
   if (!Dst.isSimple()) {
     if (Dst.isVectorElt()) {
       // Read/modify/write the vector, inserting the new element.
       llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddress(),
                                             Dst.isVolatileQualified());
+      applyNoundefToLoadInst(CGM.getCodeGenOpts().EnableNoundefLoadAttr,
+                             Dst.getType(), dyn_cast<llvm::LoadInst>(Vec));
       auto *IRStoreTy = dyn_cast<llvm::IntegerType>(Vec->getType());
       if (IRStoreTy) {
         auto *IRVecTy = llvm::FixedVectorType::get(
             Builder.getInt1Ty(), IRStoreTy->getPrimitiveSizeInBits());
         Vec = Builder.CreateBitCast(Vec, IRVecTy);
         // iN --> <N x i1>.
       }
       Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
if (!Dst.isSimple()) {
 
     if (Dst.isMatrixElt()) {
       llvm::Value *Idx = Dst.getMatrixIdx();
       if (CGM.getCodeGenOpts().OptimizationLevel > 0) {
         const auto *const MatTy = Dst.getType()->castAs<ConstantMatrixType>();
         llvm::MatrixBuilder MB(Builder);
         MB.CreateIndexAssumption(Idx, MatTy->getNumElementsFlattened());
       }
-      llvm::Instruction *Load = Builder.CreateLoad(Dst.getMatrixAddress());
+      llvm::LoadInst *Load = Builder.CreateLoad(Dst.getMatrixAddress());
+      applyNoundefToLoadInst(CGM.getCodeGenOpts().EnableNoundefLoadAttr,
+                             Dst.getType(), Load);
       llvm::Value *Vec =
           Builder.CreateInsertElement(Load, Src.getScalarVal(), Idx, "matins");
       Builder.CreateStore(Vec, Dst.getMatrixAddress(),
                           Dst.isVolatileQualified());
       return;
     }
 
     assert(Dst.isBitField() && "Unknown LValue type");

 }
 
 void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
                                                                LValue Dst) {
   // This access turns into a read/modify/write of the vector.  Load the input
   // value now.
   llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddress(),
                                         Dst.isVolatileQualified());
+  applyNoundefToLoadInst(CGM.getCodeGenOpts().EnableNoundefLoadAttr,
+                         Dst.getType(), dyn_cast<llvm::LoadInst>(Vec));
   const llvm::Constant *Elts = Dst.getExtVectorElts();
 
   llvm::Value *SrcVal = Src.getScalarVal();
 
   if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) {
     unsigned NumSrcElts = VTy->getNumElements();
     unsigned NumDstElts =
         cast<llvm::FixedVectorType>(Vec->getType())->getNumElements();

clang/test/CodeGen/matrix-type-operators.c

 typedef float fx2x3_t __attribute__((matrix_type(2, 3)));
 
 // Check that we can use matrix index expression on different floating point
 // matrixes and indices.
 void insert_double_matrix_const_idx_ll_u_double(dx5x5_t a, double d, fx2x3_t b, float e, int j, unsigned k) {
   // CHECK-LABEL: @insert_double_matrix_const_idx_ll_u_double(
   // NOOPT:         [[D:%.*]] = load double, double* %d.addr, align 8, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[D:%.*]] = load double, double* %d.addr, align 8, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
-  // CHECK-NEXT:    [[MAT:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8, !noundef [[NOUNDEF:![0-9]+]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <25 x double> [[MAT]], double [[D]], i64 5
   // CHECK-NEXT:    store <25 x double> [[MATINS]], <25 x double>* {{.*}}, align 8
   // CHECK-NEXT:    ret void
 
   a[0ll][1u] = d;
 }
 
 void insert_double_matrix_const_idx_i_u_double(dx5x5_t a, double d) {
   // CHECK-LABEL: @insert_double_matrix_const_idx_i_u_double(
   // NOOPT:         [[D:%.*]] = load double, double* %d.addr, align 8, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[D:%.*]] = load double, double* %d.addr, align 8, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
-  // CHECK-NEXT:    [[MAT:%.*]] = load <25 x double>, <25 x double>* [[MAT_ADDR:%.*]], align 8{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <25 x double>, <25 x double>* [[MAT_ADDR:%.*]], align 8, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <25 x double> [[MAT]], double [[D]], i64 21
   // CHECK-NEXT:    store <25 x double> [[MATINS]], <25 x double>* [[MAT_ADDR]], align 8
   // CHECK-NEXT:    ret void
 
   a[1][4u] = d;
 }
 
 void insert_float_matrix_const_idx_ull_i_float(fx2x3_t b, float e) {
   // CHECK-LABEL: @insert_float_matrix_const_idx_ull_i_float(
   // NOOPT:         [[E:%.*]] = load float, float* %e.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[E:%.*]] = load float, float* %e.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
-  // CHECK-NEXT:    [[MAT:%.*]] = load <6 x float>, <6 x float>* [[MAT_ADDR:%.*]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <6 x float>, <6 x float>* [[MAT_ADDR:%.*]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <6 x float> [[MAT]], float [[E]], i64 3
   // CHECK-NEXT:    store <6 x float> [[MATINS]], <6 x float>* [[MAT_ADDR]], align 4
   // CHECK-NEXT:    ret void
 
   b[1ull][1] = e;
 }
 
 void insert_float_matrix_idx_i_u_float(fx2x3_t b, float e, int j, unsigned k) {
   // CHECK-LABEL: @insert_float_matrix_idx_i_u_float(
   // NOOPT:         [[E:%.*]] = load float, float* %e.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // NOOPT-NEXT:    [[J:%.*]] = load i32, i32* %j.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[E:%.*]] = load float, float* %e.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[J:%.*]] = load i32, i32* %j.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[J_EXT:%.*]] = sext i32 [[J]] to i64
   // NOOPT-NEXT:    [[K:%.*]] = load i32, i32* %k.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[K:%.*]] = load i32, i32* %k.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[K_EXT:%.*]] = zext i32 [[K]] to i64
   // CHECK-NEXT:    [[IDX1:%.*]] = mul i64 [[K_EXT]], 2
   // CHECK-NEXT:    [[IDX2:%.*]] = add i64 [[IDX1]], [[J_EXT]]
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX2]], 6
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:    [[MAT:%.*]] = load <6 x float>, <6 x float>* [[MAT_ADDR:%.*]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <6 x float>, <6 x float>* [[MAT_ADDR:%.*]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <6 x float> [[MAT]], float [[E]], i64 [[IDX2]]
   // CHECK-NEXT:    store <6 x float> [[MATINS]], <6 x float>* [[MAT_ADDR]], align 4
   // CHECK-NEXT:    ret void
 
   b[j][k] = e;
 }
 
 void insert_float_matrix_idx_s_ull_float(fx2x3_t b, float e, short j, unsigned long long k) {
   // CHECK-LABEL: @insert_float_matrix_idx_s_ull_float(
   // NOOPT:         [[E:%.*]] = load float, float* %e.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // NOOPT-NEXT:    [[J:%.*]] = load i16, i16* %j.addr, align 2, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[E:%.*]] = load float, float* %e.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[J:%.*]] = load i16, i16* %j.addr, align 2, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[J_EXT:%.*]] = sext i16 [[J]] to i64
   // NOOPT-NEXT:    [[K:%.*]] = load i64, i64* %k.addr, align 8, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[K:%.*]] = load i64, i64* %k.addr, align 8, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[IDX1:%.*]] = mul i64 [[K]], 2
   // CHECK-NEXT:    [[IDX2:%.*]] = add i64 [[IDX1]], [[J_EXT]]
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX2]], 6
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:    [[MAT:%.*]] = load <6 x float>, <6 x float>* [[MAT_ADDR:%.*]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <6 x float>, <6 x float>* [[MAT_ADDR:%.*]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <6 x float> [[MAT]], float [[E]], i64 [[IDX2]]
   // CHECK-NEXT:    store <6 x float> [[MATINS]], <6 x float>* [[MAT_ADDR]], align 4
   // CHECK-NEXT:    ret void
 
   (b)[j][k] = e;
 }
 
 // Check that we can can use matrix index expressions on integer matrixes.
 typedef int ix9x3_t __attribute__((matrix_type(9, 3)));
 void insert_int_idx_expr(ix9x3_t a, int i) {
   // CHECK-LABEL: @insert_int_idx_expr(
   // NOOPT:         [[I1:%.*]] = load i32, i32* %i.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // NOOPT-NEXT:    [[I2:%.*]] = load i32, i32* %i.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[I1:%.*]] = load i32, i32* %i.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[I2:%.*]] = load i32, i32* %i.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[I2_ADD:%.*]] = add nsw i32 4, [[I2]]
   // CHECK-NEXT:    [[ADD_EXT:%.*]] = sext i32 [[I2_ADD]] to i64
   // CHECK-NEXT:    [[IDX2:%.*]] = add i64 18, [[ADD_EXT]]
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX2]], 27
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:    [[MAT:%.*]] = load <27 x i32>, <27 x i32>* [[MAT_ADDR:%.*]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <27 x i32>, <27 x i32>* [[MAT_ADDR:%.*]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <27 x i32> [[MAT]], i32 [[I1]], i64 [[IDX2]]
   // CHECK-NEXT:    store <27 x i32> [[MATINS]], <27 x i32>* [[MAT_ADDR]], align 4
   // CHECK-NEXT:    ret void
 
   a[4 + i][1 + 1u] = i;
 }
 
 // Check that we can can use matrix index expressions on FP and integer
 // matrixes.
 typedef int ix9x3_t __attribute__((matrix_type(9, 3)));
 void insert_float_into_int_matrix(ix9x3_t *a, int i) {
   // CHECK-LABEL: @insert_float_into_int_matrix(
   // NOOPT:         [[I:%.*]] = load i32, i32* %i.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[I:%.*]] = load i32, i32* %i.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // NOOPT-NEXT:    [[MAT_ADDR1:%.*]] = load [27 x i32]*, [27 x i32]** %a.addr, align 8, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[MAT_ADDR1:%.*]] = load [27 x i32]*, [27 x i32]** %a.addr, align 8, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MAT_ADDR2:%.*]] = bitcast [27 x i32]* [[MAT_ADDR1]] to <27 x i32>*
-  // CHECK-NEXT:    [[MAT:%.*]] = load <27 x i32>, <27 x i32>* [[MAT_ADDR2]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <27 x i32>, <27 x i32>* [[MAT_ADDR2]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <27 x i32> [[MAT]], i32 [[I]], i64 13
   // CHECK-NEXT:    store <27 x i32> [[MATINS]], <27 x i32>* [[MAT_ADDR2]], align 4
   // CHECK-NEXT:    ret void
 
   (*a)[4][1] = i;
 }
 
 // Check that we can use overloaded matrix index expressions on matrixes with
 // matching dimensions, but different element types.
 typedef double dx3x3_t __attribute__((matrix_type(3, 3)));
 typedef float fx3x3_t __attribute__((matrix_type(3, 3)));
 void insert_matching_dimensions1(dx3x3_t a, double i) {
   // CHECK-LABEL: @insert_matching_dimensions1(
   // NOOPT:         [[I:%.*]] = load double, double* %i.addr, align 8, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[I:%.*]] = load double, double* %i.addr, align 8, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
-  // CHECK-NEXT:    [[MAT:%.*]] = load <9 x double>, <9 x double>* [[MAT_ADDR:%.*]], align 8{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <9 x double>, <9 x double>* [[MAT_ADDR:%.*]], align 8, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <9 x double> [[MAT]], double [[I]], i64 5
   // CHECK-NEXT:    store <9 x double> [[MATINS]], <9 x double>* [[MAT_ADDR]], align 8
   // CHECK-NEXT:    ret void
 
   a[2u][1u] = i;
 }
 
 void insert_matching_dimensions(fx3x3_t b, float e) {
   // CHECK-LABEL: @insert_matching_dimensions(
   // NOOPT:         [[E:%.*]] = load float, float* %e.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT:           [[E:%.*]] = load float, float* %e.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
-  // CHECK-NEXT:    [[MAT:%.*]] = load <9 x float>, <9 x float>* [[MAT_ADDR:%.*]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <9 x float>, <9 x float>* [[MAT_ADDR:%.*]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <9 x float> [[MAT]], float [[E]], i64 7
   // CHECK-NEXT:    store <9 x float> [[MATINS]], <9 x float>* [[MAT_ADDR]], align 4
   // CHECK-NEXT:    ret void
 
   b[1u][2u] = e;
 }
 
 double extract_double(dx5x5_t a) {
void insert_extract(dx5x5_t a, fx3x3_t b, unsigned long j, short k) {
   // OPT-NEXT:      [[MAT:%.*]] = load <9 x float>, <9 x float>* [[MAT_ADDR:%.*]], align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATEXT:%.*]] = extractelement <9 x float> [[MAT]], i64 [[IDX2]]
   // NOOPT-NEXT:    [[J:%.*]] = load i64, i64* %j.addr, align 8, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[J:%.*]] = load i64, i64* %j.addr, align 8, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[IDX3:%.*]] = mul i64 [[J]], 3
   // CHECK-NEXT:    [[IDX4:%.*]] = add i64 [[IDX3]], 2
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX4]], 9
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:    [[MAT2:%.*]] = load <9 x float>, <9 x float>* [[MAT_ADDR]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT2:%.*]] = load <9 x float>, <9 x float>* [[MAT_ADDR]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <9 x float> [[MAT2]], float [[MATEXT]], i64 [[IDX4]]
   // CHECK-NEXT:    store <9 x float> [[MATINS]], <9 x float>* [[MAT_ADDR]], align 4
   // CHECK-NEXT:    ret void
 
   b[2][j] = b[0][k];
 }
 
 void insert_compound_stmt(dx5x5_t a) {
   // CHECK-LABEL: define{{.*}} void @insert_compound_stmt(<25 x double> noundef %a)
   // CHECK:        [[A:%.*]] = load <25 x double>, <25 x double>* [[A_PTR:%.*]], align 8, !noundef [[NOUNDEF:![0-9]+]]{{$}}
   // CHECK-NEXT:   [[EXT:%.*]] = extractelement <25 x double> [[A]], i64 17
   // CHECK-NEXT:   [[SUB:%.*]] = fsub double [[EXT]], 1.000000e+00
-  // CHECK-NEXT:   [[A2:%.*]] = load <25 x double>, <25 x double>* [[A_PTR]], align 8{{$}}
+  // CHECK-NEXT:   [[A2:%.*]] = load <25 x double>, <25 x double>* [[A_PTR]], align 8, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:   [[INS:%.*]] = insertelement <25 x double> [[A2]], double [[SUB]], i64 17
   // CHECK-NEXT:   store <25 x double> [[INS]], <25 x double>* [[A_PTR]], align 8
   // CHECK-NEXT:   ret void
 
   a[2][3] -= 1.0;
 }
 
 struct Foo {
void insert_compound_stmt_field(struct Foo *a, float f, unsigned i, unsigned j) {
   // CHECK-NEXT:    [[MAT_PTR:%.*]] = bitcast [6 x float]* %mat to <6 x float>*
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX2]], 6
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
   // CHECK-NEXT:    [[MAT:%.*]] = load <6 x float>, <6 x float>* [[MAT_PTR]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[EXT:%.*]] = extractelement <6 x float> [[MAT]], i64 [[IDX2]]
   // CHECK-NEXT:    [[SUM:%.*]] = fadd float [[EXT]], {{.*}}
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX2]], 6
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:    [[MAT2:%.*]] = load <6 x float>, <6 x float>* [[MAT_PTR]], align 4{{$}}
+  // CHECK-NEXT:    [[MAT2:%.*]] = load <6 x float>, <6 x float>* [[MAT_PTR]], align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[INS:%.*]] = insertelement <6 x float> [[MAT2]], float [[SUM]], i64 [[IDX2]]
   // CHECK-NEXT:    store <6 x float> [[INS]], <6 x float>* [[MAT_PTR]], align 4
   // CHECK-NEXT:    ret void
 
   a->mat[i][j] += f;
 }
 
 void matrix_as_idx(ix9x3_t a, int i, int j, dx5x5_t b) {
void matrix_as_idx(ix9x3_t a, int i, int j, dx5x5_t b) {
   // OPT-NEXT:    [[A2:%.*]] = load <27 x i32>, <27 x i32>* {{.*}}, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:  [[MI2:%.*]] = extractelement <27 x i32> [[A2]], i64 [[IDX2_2]]
   // CHECK-NEXT:  [[MI3:%.*]] = add nsw i32 [[MI2]], 2
   // CHECK-NEXT:  [[MI3_EXT:%.*]] = sext i32 [[MI3]] to i64
   // CHECK-NEXT:  [[IDX3_1:%.*]] = mul i64 [[MI3_EXT]], 5
   // CHECK-NEXT:  [[IDX3_2:%.*]] = add i64 [[IDX3_1]], [[MI1_EXT]]
   // OPT-NEXT:    [[CMP:%.*]] = icmp ult i64 [[IDX3_2]], 25
   // OPT-NEXT:    call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:  [[B:%.*]] = load <25 x double>, <25 x double>* [[B_PTR:%.*]], align 8{{$}}
+  // CHECK-NEXT:  [[B:%.*]] = load <25 x double>, <25 x double>* [[B_PTR:%.*]], align 8, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:  [[INS:%.*]] = insertelement <25 x double> [[B]], double 1.500000e+00, i64 [[IDX3_2]]
   // CHECK-NEXT:  store <25 x double> [[INS]], <25 x double>* [[B_PTR]], align 8
   b[a[i][j]][a[j][i] + 2] = 1.5;
 }

clang/test/CodeGen/vector-noundef.c

 // CHECK-NEXT:    [[TMP5:%.*]] = load <4 x float>, <4 x float>* [[__B_ADDR_I2]], align 16, !noundef [[NOUNDEF2]]
 // CHECK-NEXT:    store <4 x float> [[TMP4]], <4 x float>* [[__A_ADDR_I]], align 16
 // CHECK-NEXT:    store <4 x float> [[TMP5]], <4 x float>* [[__B_ADDR_I]], align 16
 // CHECK-NEXT:    [[TMP6:%.*]] = load <4 x float>, <4 x float>* [[__B_ADDR_I]], align 16, !noundef [[NOUNDEF2]]
 // CHECK-NEXT:    [[VECEXT_I:%.*]] = extractelement <4 x float> [[TMP6]], i32 0
 // CHECK-NEXT:    [[TMP7:%.*]] = load <4 x float>, <4 x float>* [[__A_ADDR_I]], align 16, !noundef [[NOUNDEF2]]
 // CHECK-NEXT:    [[VECEXT1_I:%.*]] = extractelement <4 x float> [[TMP7]], i32 0
 // CHECK-NEXT:    [[DIV_I:%.*]] = fdiv float [[VECEXT1_I]], [[VECEXT_I]]
-// CHECK-NEXT:    [[TMP8:%.*]] = load <4 x float>, <4 x float>* [[__A_ADDR_I]], align 16
+// CHECK-NEXT:    [[TMP8:%.*]] = load <4 x float>, <4 x float>* [[__A_ADDR_I]], align 16, !noundef [[NOUNDEF2]]
 // CHECK-NEXT:    [[VECINS_I:%.*]] = insertelement <4 x float> [[TMP8]], float [[DIV_I]], i32 0
 // CHECK-NEXT:    store <4 x float> [[VECINS_I]], <4 x float>* [[__A_ADDR_I]], align 16
 // CHECK-NEXT:    [[TMP9:%.*]] = load <4 x float>, <4 x float>* [[__A_ADDR_I]], align 16, !noundef [[NOUNDEF2]]
 // CHECK-NEXT:    store <4 x float> [[TMP9]], <4 x float>* [[__A_ADDR_I2]], align 16
 // CHECK-NEXT:    [[TMP10:%.*]] = load i8, i8* [[__U_ADDR_I]], align 1
 // CHECK-NEXT:    [[TMP11:%.*]] = load <4 x float>, <4 x float>* [[__A_ADDR_I2]], align 16, !noundef [[NOUNDEF2]]
 // CHECK-NEXT:    [[TMP12:%.*]] = load <4 x float>, <4 x float>* [[__W_ADDR_I]], align 16, !noundef [[NOUNDEF2]]
 // CHECK-NEXT:    [[TMP13:%.*]] = extractelement <4 x float> [[TMP11]], i64 0

clang/test/CodeGenCXX/matrix-type-operators.cpp

void test_insert_template1(MyMatrix<unsigned, 2, 2> &Mat, unsigned e, unsigned i, unsigned j) {
   // CHECK-NEXT:    [[I_EXT:%.*]] = zext i32 [[I]] to i64
   // NOOPT-NEXT:    [[J:%.*]] = load i32, ptr %j.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[J:%.*]] = load i32, ptr %j.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[J_EXT:%.*]] = zext i32 [[J]] to i64
   // CHECK-NEXT:    [[IDX1:%.*]] = mul i64 [[J_EXT]], 2
   // CHECK-NEXT:    [[IDX2:%.*]] = add i64 [[IDX1]], [[I_EXT]]
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX2]], 4
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:    [[MAT:%.*]] = load <4 x i32>, ptr {{.*}}, align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <4 x i32>, ptr {{.*}}, align 4, !noundef [[NOUNDEF:![0-9]+]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <4 x i32> [[MAT]], i32 [[E]], i64 [[IDX2]]
   // CHECK-NEXT:    store <4 x i32> [[MATINS]], ptr {{.*}}, align 4
   // CHECK-NEXT:    ret void
 
   insert(Mat, e, i, j);
 }
 
 void test_insert_template2(MyMatrix<float, 3, 8> &Mat, float e) {
void test_insert_template2(MyMatrix<float, 3, 8> &Mat, float e) {
   // CHECK-NEXT:    [[I_EXT:%.*]] = zext i32 [[I]] to i64
   // NOOPT-NEXT:    [[J:%.*]] = load i32, ptr %j.addr, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:      [[J:%.*]] = load i32, ptr %j.addr, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[J_EXT:%.*]] = zext i32 [[J]] to i64
   // CHECK-NEXT:    [[IDX1:%.*]] = mul i64 [[J_EXT]], 3
   // CHECK-NEXT:    [[IDX2:%.*]] = add i64 [[IDX1]], [[I_EXT]]
   // OPT-NEXT:      [[CMP:%.*]] = icmp ult i64 [[IDX2]], 24
   // OPT-NEXT:      call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:    [[MAT:%.*]] = load <24 x float>, ptr {{.*}}, align 4{{$}}
+  // CHECK-NEXT:    [[MAT:%.*]] = load <24 x float>, ptr {{.*}}, align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:    [[MATINS:%.*]] = insertelement <24 x float> [[MAT]], float [[E]], i64 [[IDX2]]
   // CHECK-NEXT:    store <24 x float> [[MATINS]], ptr {{.*}}, align 4
   // CHECK-NEXT:    ret void
 
   insert(Mat, e, 2, 5);
 }
 
 template <typename EltTy, unsigned Rows, unsigned Columns>
void test_constexpr1(matrix_type<float, 4, 4> &m) {
   // CHECK-NEXT:   [[I_EXT:%.*]] = zext i32 [[I]] to i64
   // NOOPT-NEXT:   [[I2:%.*]] = load i32, ptr %i, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:     [[I2:%.*]] = load i32, ptr %i, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:   [[I2_EXT:%.*]] = zext i32 [[I2]] to i64
   // CHECK-NEXT:   [[IDX1:%.*]] = mul i64 [[I2_EXT]], 4
   // CHECK-NEXT:   [[IDX2:%.*]] = add i64 [[IDX1]], [[I_EXT]]
   // OPT-NEXT:     [[CMP:%.*]] = icmp ult i64 [[IDX2]], 16
   // OPT-NEXT:     call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:   [[MAT:%.*]] = load <16 x float>, ptr %result, align 4{{$}}
+  // CHECK-NEXT:   [[MAT:%.*]] = load <16 x float>, ptr %result, align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:   [[MATINS:%.*]] = insertelement <16 x float> [[MAT]], float 1.000000e+00, i64 [[IDX2]]
   // CHECK-NEXT:   store <16 x float> [[MATINS]], ptr %result, align 4
   // CHECK-NEXT:   br label %for.inc
   m = m + identmatrix;
 }
 
 void test_constexpr2(matrix_type<int, 5, 5> &m) {
   // CHECK-LABEL: define{{.*}} void @_Z15test_constexpr2Ru11matrix_typeILm5ELm5EiE(
void test_constexpr2(matrix_type<int, 5, 5> &m) {
   // CHECK-NEXT:   [[I_EXT:%.*]] = zext i32 [[I]] to i64
   // NOOPT-NEXT:   [[I2:%.*]] = load i32, ptr %i, align 4, !noundef [[NOUNDEF]]{{$}}
   // OPT-NEXT:     [[I2:%.*]] = load i32, ptr %i, align 4, !tbaa !{{[0-9]+}}, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:   [[I2_EXT:%.*]] = zext i32 [[I2]] to i64
   // CHECK-NEXT:   [[IDX1:%.*]] = mul i64 [[I2_EXT]], 5
   // CHECK-NEXT:   [[IDX2:%.*]] = add i64 [[IDX1]], [[I_EXT]]
   // OPT-NEXT:     [[CMP:%.*]] = icmp ult i64 [[IDX2]], 25
   // OPT-NEXT:     call void @llvm.assume(i1 [[CMP]])
-  // CHECK-NEXT:   [[MAT:%.*]] = load <25 x i32>, ptr %result, align 4{{$}}
+  // CHECK-NEXT:   [[MAT:%.*]] = load <25 x i32>, ptr %result, align 4, !noundef [[NOUNDEF]]{{$}}
   // CHECK-NEXT:   [[MATINS:%.*]] = insertelement <25 x i32> [[MAT]], i32 1, i64 [[IDX2]]
   // CHECK-NEXT:   store <25 x i32> [[MATINS]], ptr %result, align 4
   // CHECK-NEXT:   br label %for.inc
 
   m = identmatrix - m + 1;
 }

clang/test/CodeGenCXX/vector-noundef.cpp

 // DISABLE-NEXT:    [[TMP2:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <2 x i32> <i32 0, i32 1>
 // DISABLE-NEXT:    [[TMP3:%.*]] = load ptr, ptr [[VEC2_ADDR]], align 8
 // DISABLE-NEXT:    store <2 x float> [[TMP2]], ptr [[TMP3]], align 8
 // DISABLE-NEXT:    ret void
 //
 void vectorSubsection(VecOfTwoFloats& vec2, VecOfFourFloats& vec4) {
     vec2 = vec4.xy;
 }
+
+// CHECK-LABEL: @_Z18vectorStoreElementRDv2_ff(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VEC2_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NEXT:    [[F_ADDR:%.*]] = alloca float, align 4
+// CHECK-NEXT:    store ptr [[VEC2:%.*]], ptr [[VEC2_ADDR]], align 8
+// CHECK-NEXT:    store float [[F:%.*]], ptr [[F_ADDR]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load float, ptr [[F_ADDR]], align 4, !noundef [[NOUNDEF2]]
+// CHECK-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[VEC2_ADDR]], align 8
+// CHECK-NEXT:    [[TMP2:%.*]] = load <2 x float>, ptr [[TMP1]], align 8, !noundef [[NOUNDEF2]]
+// CHECK-NEXT:    [[TMP3:%.*]] = insertelement <2 x float> [[TMP2]], float [[TMP0]], i64 0
+// CHECK-NEXT:    store <2 x float> [[TMP3]], ptr [[TMP1]], align 8
+// CHECK-NEXT:    ret void
+//
+// DISABLE-LABEL: @_Z18vectorStoreElementRDv2_ff(
+// DISABLE-NEXT:  entry:
+// DISABLE-NEXT:    [[VEC2_ADDR:%.*]] = alloca ptr, align 8
+// DISABLE-NEXT:    [[F_ADDR:%.*]] = alloca float, align 4
+// DISABLE-NEXT:    store ptr [[VEC2:%.*]], ptr [[VEC2_ADDR]], align 8
+// DISABLE-NEXT:    store float [[F:%.*]], ptr [[F_ADDR]], align 4
+// DISABLE-NEXT:    [[TMP0:%.*]] = load float, ptr [[F_ADDR]], align 4
+// DISABLE-NEXT:    [[TMP1:%.*]] = load ptr, ptr [[VEC2_ADDR]], align 8
+// DISABLE-NEXT:    [[TMP2:%.*]] = load <2 x float>, ptr [[TMP1]], align 8
+// DISABLE-NEXT:    [[TMP3:%.*]] = insertelement <2 x float> [[TMP2]], float [[TMP0]], i64 0
+// DISABLE-NEXT:    store <2 x float> [[TMP3]], ptr [[TMP1]], align 8
+// DISABLE-NEXT:    ret void
+//
+void vectorStoreElement(VecOfTwoFloats& vec2, float f) {
+    vec2.x = f;
+}
+
+// CHECK-LABEL: @_Z12vectorRotateRDv4_f(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VEC4_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NEXT:    store ptr [[VEC4:%.*]], ptr [[VEC4_ADDR]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[VEC4_ADDR]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[TMP0]], align 16, !noundef [[NOUNDEF2]]
+// CHECK-NEXT:    [[TMP2:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <3 x i32> <i32 2, i32 1, i32 0>
+// CHECK-NEXT:    [[TMP3:%.*]] = load ptr, ptr [[VEC4_ADDR]], align 8
+// CHECK-NEXT:    [[TMP4:%.*]] = load <4 x float>, ptr [[TMP3]], align 16, !noundef [[NOUNDEF2]]
+// CHECK-NEXT:    [[TMP5:%.*]] = shufflevector <3 x float> [[TMP2]], <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef>
+// CHECK-NEXT:    [[TMP6:%.*]] = shufflevector <4 x float> [[TMP4]], <4 x float> [[TMP5]], <4 x i32> <i32 4, i32 5, i32 6, i32 3>
+// CHECK-NEXT:    store <4 x float> [[TMP6]], ptr [[TMP3]], align 16
+// CHECK-NEXT:    ret void
+//
+// DISABLE-LABEL: @_Z12vectorRotateRDv4_f(
+// DISABLE-NEXT:  entry:
+// DISABLE-NEXT:    [[VEC4_ADDR:%.*]] = alloca ptr, align 8
+// DISABLE-NEXT:    store ptr [[VEC4:%.*]], ptr [[VEC4_ADDR]], align 8
+// DISABLE-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[VEC4_ADDR]], align 8
+// DISABLE-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[TMP0]], align 16
+// DISABLE-NEXT:    [[TMP2:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <3 x i32> <i32 2, i32 1, i32 0>
+// DISABLE-NEXT:    [[TMP3:%.*]] = load ptr, ptr [[VEC4_ADDR]], align 8
+// DISABLE-NEXT:    [[TMP4:%.*]] = load <4 x float>, ptr [[TMP3]], align 16
+// DISABLE-NEXT:    [[TMP5:%.*]] = shufflevector <3 x float> [[TMP2]], <3 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 undef>
+// DISABLE-NEXT:    [[TMP6:%.*]] = shufflevector <4 x float> [[TMP4]], <4 x float> [[TMP5]], <4 x i32> <i32 4, i32 5, i32 6, i32 3>
+// DISABLE-NEXT:    store <4 x float> [[TMP6]], ptr [[TMP3]], align 16
+// DISABLE-NEXT:    ret void
+//
+void vectorRotate(VecOfFourFloats& vec4) {
+    vec4.xyz = vec4.zyx;
+}