[SVE] Eliminate calls to default-false VectorType::get() from polly

[fpetrogalli]

LGTM, with one nit that I think it is worth addressing before submitting.

Thank you

polly/lib/CodeGen/BlockGenerators.cpp

1108

While on this, maybe rename the variable VectorType to something that doesn't confuse the types? VecTy?

[ctetreau]

rebase

[ctetreau]

polly/lib/CodeGen/BlockGenerators.cpp

1108

Wow, yeah, that's a bit of an unfortunate name...

[ctetreau]

address code review issues

[ctetreau]

Oh gosh, it's like that everywhere

polly/lib/CodeGen/BlockGenerators.cpp

Value *VectorBlockGenerator::getVectorValue(ScopStmt &Stmt, Value *Old,
                                             ValueMapT &VectorMap,
                                             VectorValueMapT &ScalarMaps,
                                             Loop *L) {
   if (Value *NewValue = VectorMap.lookup(Old))
     return NewValue;
 
   int Width = getVectorWidth();
 
-  Value *Vector = UndefValue::get(VectorType::get(Old->getType(), Width));
+  Value *Vector = UndefValue::get(FixedVectorType::get(Old->getType(), Width));
 
   for (int Lane = 0; Lane < Width; Lane++)
     Vector = Builder.CreateInsertElement(
         Vector, getNewValue(Stmt, Old, ScalarMaps[Lane], VLTS[Lane], L),
         Builder.getInt32(Lane));
 
   VectorMap[Old] = Vector;
 
   return Vector;
 }
 
 Type *VectorBlockGenerator::getVectorPtrTy(const Value *Val, int Width) {
   PointerType *PointerTy = dyn_cast<PointerType>(Val->getType());
   assert(PointerTy && "PointerType expected");
 
   Type *ScalarType = PointerTy->getElementType();
-  VectorType *VectorType = VectorType::get(ScalarType, Width);
+  auto *VectorType = FixedVectorType::get(ScalarType, Width);
 
   return PointerType::getUnqual(VectorType);
 }
 
 Value *VectorBlockGenerator::generateStrideOneLoad(
     ScopStmt &Stmt, LoadInst *Load, VectorValueMapT &ScalarMaps,
     __isl_keep isl_id_to_ast_expr *NewAccesses, bool NegativeStride = false) {
   unsigned VectorWidth = getVectorWidth();
Value *VectorPtr = Builder.CreateBitCast(NewPointer, VectorPtrType,
                                            Load->getName() + "_p_vec_p");
   LoadInst *ScalarLoad =
       Builder.CreateLoad(VectorPtr, Load->getName() + "_p_splat_one");
 
   if (!Aligned)
     ScalarLoad->setAlignment(Align(8));
 
   Constant *SplatVector = Constant::getNullValue(
-      VectorType::get(Builder.getInt32Ty(), getVectorWidth()));
+      FixedVectorType::get(Builder.getInt32Ty(), getVectorWidth()));
 
   Value *VectorLoad = Builder.CreateShuffleVector(
       ScalarLoad, ScalarLoad, SplatVector, Load->getName() + "_p_splat");
   return VectorLoad;
 }
 
 Value *VectorBlockGenerator::generateUnknownStrideLoad(
     ScopStmt &Stmt, LoadInst *Load, VectorValueMapT &ScalarMaps,
     __isl_keep isl_id_to_ast_expr *NewAccesses) {
   int VectorWidth = getVectorWidth();
   auto *Pointer = Load->getPointerOperand();
-  VectorType *VectorType = VectorType::get(
+  auto *VectorType = FixedVectorType::get(
       dyn_cast<PointerType>(Pointer->getType())->getElementType(), VectorWidth);
 
   Value *Vector = UndefValue::get(VectorType);
 
   for (int i = 0; i < VectorWidth; i++) {
     Value *NewPointer = generateLocationAccessed(Stmt, Load, ScalarMaps[i],
                                                  VLTS[i], NewAccesses);
     Value *ScalarLoad =
void VectorBlockGenerator::copyUnaryInst(ScopStmt &Stmt, UnaryInstruction *Inst,
                                          VectorValueMapT &ScalarMaps) {
   int VectorWidth = getVectorWidth();
   Value *NewOperand = getVectorValue(Stmt, Inst->getOperand(0), VectorMap,
                                      ScalarMaps, getLoopForStmt(Stmt));
 
   assert(isa<CastInst>(Inst) && "Can not generate vector code for instruction");
 
   const CastInst *Cast = dyn_cast<CastInst>(Inst);
-  VectorType *DestType = VectorType::get(Inst->getType(), VectorWidth);
+  auto *DestType = FixedVectorType::get(Inst->getType(), VectorWidth);
   VectorMap[Inst] = Builder.CreateCast(Cast->getOpcode(), NewOperand, DestType);
 }
 
 void VectorBlockGenerator::copyBinaryInst(ScopStmt &Stmt, BinaryOperator *Inst,
                                           ValueMapT &VectorMap,
                                           VectorValueMapT &ScalarMaps) {
   Loop *L = getLoopForStmt(Stmt);
   Value *OpZero = Inst->getOperand(0);
void VectorBlockGenerator::copyInstScalarized(
   for (int VectorLane = 0; VectorLane < getVectorWidth(); VectorLane++)
     BlockGenerator::copyInstruction(Stmt, Inst, ScalarMaps[VectorLane],
                                     VLTS[VectorLane], NewAccesses);
 
   if (!VectorType::isValidElementType(Inst->getType()) || !HasVectorOperand)
     return;
 
   // Make the result available as vector value.
-  VectorType *VectorType = VectorType::get(Inst->getType(), VectorWidth);
+  auto *VectorType = FixedVectorType::get(Inst->getType(), VectorWidth);
   Value *Vector = UndefValue::get(VectorType);
 
   for (int i = 0; i < VectorWidth; i++)
     Vector = Builder.CreateInsertElement(Vector, ScalarMaps[i][Inst],
                                          Builder.getInt32(i));
 
   VectorMap[Inst] = Vector;
 }
if (MA->isArrayKind() || MA->isWrite())
       continue;
 
     auto *Address = getOrCreateAlloca(*MA);
     Type *VectorPtrType = getVectorPtrTy(Address, 1);
     Value *VectorPtr = Builder.CreateBitCast(Address, VectorPtrType,
                                              Address->getName() + "_p_vec_p");
     auto *Val = Builder.CreateLoad(VectorPtr, Address->getName() + ".reload");
     Constant *SplatVector = Constant::getNullValue(
-        VectorType::get(Builder.getInt32Ty(), getVectorWidth()));
+        FixedVectorType::get(Builder.getInt32Ty(), getVectorWidth()));
 
     Value *VectorVal = Builder.CreateShuffleVector(
         Val, Val, SplatVector, Address->getName() + "_p_splat");
     VectorBlockMap[MA->getAccessValue()] = VectorVal;
   }
 }
 
 void VectorBlockGenerator::verifyNoScalarStores(ScopStmt &Stmt) {