[Scalarizer] Scalarize freeze instruction

[foad]

llvm/test/Transforms/Scalarizer/basic.ll

836–842

The code is much more verbose here, but I assume this is what the scalarizer is supposed to do?

[nikic]

LGTM

llvm/lib/Transforms/Scalar/Scalarizer.cpp

public:
   bool visitBitCastInst(BitCastInst &BCI);
   bool visitInsertElementInst(InsertElementInst &IEI);
   bool visitExtractElementInst(ExtractElementInst &EEI);
   bool visitShuffleVectorInst(ShuffleVectorInst &SVI);
   bool visitPHINode(PHINode &PHI);
   bool visitLoadInst(LoadInst &LI);
   bool visitStoreInst(StoreInst &SI);
   bool visitCallInst(CallInst &ICI);
+  bool visitFreezeInst(FreezeInst &FI);
 
 private:
   Scatterer scatter(Instruction *Point, Value *V, Type *PtrElemTy = nullptr);
   void gather(Instruction *Op, const ValueVector &CV);
   void replaceUses(Instruction *Op, Value *CV);
   bool canTransferMetadata(unsigned Kind);
   void transferMetadataAndIRFlags(Instruction *Op, const ValueVector &CV);
   std::optional<VectorLayout> getVectorLayout(Type *Ty, Align Alignment,
bool ScalarizerVisitor::visitStoreInst(StoreInst &SI) {
   transferMetadataAndIRFlags(&SI, Stores);
   return true;
 }
 
 bool ScalarizerVisitor::visitCallInst(CallInst &CI) {
   return splitCall(CI);
 }
 
+bool ScalarizerVisitor::visitFreezeInst(FreezeInst &FI) {
+  return splitUnary(FI, [](IRBuilder<> &Builder, Value *Op, const Twine &Name) {
+    return Builder.CreateFreeze(Op, Name);
+  });
+}
+
 // Delete the instructions that we scalarized.  If a full vector result
 // is still needed, recreate it using InsertElements.
 bool ScalarizerVisitor::finish() {
   // The presence of data in Gathered or Scattered indicates changes
   // made to the Function.
   if (Gathered.empty() && Scattered.empty() && !Scalarized)
     return false;
   for (const auto &GMI : Gathered) {

llvm/test/Transforms/Scalarizer/basic.ll

;
   %v0 = extractelement <2 x i32> %srcvec, i32 0
   %t0 = insertelement <2 x i32> undef, i32 %v0, i32 0
   %t1 = insertelement <2 x i32> %t0, i32 %v1, i32 1
   ret <2 x i32> %t1
 }
 
 define <2 x i32> @f24(<2 x i32> %src) {
 ; CHECK-LABEL: @f24(
-; CHECK-NEXT:    [[FRZ:%.*]] = freeze <2 x i32> [[SRC:%.*]]
+; CHECK-NEXT:    [[SRC_I0:%.*]] = extractelement <2 x i32> [[SRC:%.*]], i64 0
+; CHECK-NEXT:    [[FRZ_I0:%.*]] = freeze i32 [[SRC_I0]]
+; CHECK-NEXT:    [[SRC_I1:%.*]] = extractelement <2 x i32> [[SRC]], i64 1
+; CHECK-NEXT:    [[FRZ_I1:%.*]] = freeze i32 [[SRC_I1]]
+; CHECK-NEXT:    [[FRZ_UPTO0:%.*]] = insertelement <2 x i32> poison, i32 [[FRZ_I0]], i64 0
+; CHECK-NEXT:    [[FRZ:%.*]] = insertelement <2 x i32> [[FRZ_UPTO0]], i32 [[FRZ_I1]], i64 1
 ; CHECK-NEXT:    ret <2 x i32> [[FRZ]]
 ;
   %frz = freeze <2 x i32> %src
   ret <2 x i32> %frz
 }
 
 define <2 x float> @f25(<2 x float> %src) {
 ; CHECK-LABEL: @f25(
 ; CHECK-NEXT:    [[SRC_I0:%.*]] = extractelement <2 x float> [[SRC:%.*]], i64 0
 ; CHECK-NEXT:    [[ADD_I0:%.*]] = fadd float [[SRC_I0]], [[SRC_I0]]
 ; CHECK-NEXT:    [[SRC_I1:%.*]] = extractelement <2 x float> [[SRC]], i64 1
 ; CHECK-NEXT:    [[ADD_I1:%.*]] = fadd float [[SRC_I1]], [[SRC_I1]]
-; CHECK-NEXT:    [[ADD_UPTO0:%.*]] = insertelement <2 x float> poison, float [[ADD_I0]], i64 0
-; CHECK-NEXT:    [[ADD:%.*]] = insertelement <2 x float> [[ADD_UPTO0]], float [[ADD_I1]], i64 1
-; CHECK-NEXT:    [[FRZ:%.*]] = freeze <2 x float> [[ADD]]
-; CHECK-NEXT:    [[FRZ_I0:%.*]] = extractelement <2 x float> [[FRZ]], i64 0
+; CHECK-NEXT:    [[FRZ_I0:%.*]] = freeze float [[ADD_I0]]
+; CHECK-NEXT:    [[FRZ_I1:%.*]] = freeze float [[ADD_I1]]
 ; CHECK-NEXT:    [[MUL_I0:%.*]] = fmul float [[FRZ_I0]], [[FRZ_I0]]
-; CHECK-NEXT:    [[FRZ_I1:%.*]] = extractelement <2 x float> [[FRZ]], i64 1
 ; CHECK-NEXT:    [[MUL_I1:%.*]] = fmul float [[FRZ_I1]], [[FRZ_I1]]
 ; CHECK-NEXT:    [[MUL_UPTO0:%.*]] = insertelement <2 x float> poison, float [[MUL_I0]], i64 0
 ; CHECK-NEXT:    [[MUL:%.*]] = insertelement <2 x float> [[MUL_UPTO0]], float [[MUL_I1]], i64 1
 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 ;
   %add = fadd <2 x float> %src, %src
   %frz = freeze <2 x float> %add
   %mul = fmul <2 x float> %frz, %frz