Get the address space within getVectorPtrTy

[ctetreau]

Summary

getVectorPtrTy is private to VectorBlockGenerator, and all uses query
the address space from the passed-in pointer prior to calling it.

[efriedma]

LGTM

polly/include/polly/CodeGen/BlockGenerators.h

VectorBlockGenerator(BlockGenerator &BlockGen,
                        std::vector<LoopToScevMapT> &VLTS,
                        __isl_keep isl_map *Schedule);
 
   int getVectorWidth();
 
   Value *getVectorValue(ScopStmt &Stmt, Value *Old, ValueMapT &VectorMap,
                         VectorValueMapT &ScalarMaps, Loop *L);
 
-  Type *getVectorPtrTy(const Value *V, int Width, unsigned AddrSpace);
+  Type *getVectorPtrTy(const Value *V, int Width);
 
   /// Load a vector from a set of adjacent scalars
   ///
   /// In case a set of scalars is known to be next to each other in memory,
   /// create a vector load that loads those scalars
   ///
   /// %vector_ptr= bitcast double* %p to <4 x double>*
   /// %vec_full = load <4 x double>* %vector_ptr

polly/lib/CodeGen/BlockGenerators.cpp

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,
-                                           unsigned AddrSpace) {
-  PointerType *PointerTy = dyn_cast<PointerType>(Val->getType());
-  assert(PointerTy && "PointerType expected");
+Type *VectorBlockGenerator::getVectorPtrTy(const Value *Val, int Width) {
+  auto *PointerTy = cast<PointerType>(Val->getType());
+  unsigned AddrSpace = PointerTy->getAddressSpace();
 
   Type *ScalarType = PointerTy->getElementType();
   auto *FVTy = FixedVectorType::get(ScalarType, Width);
 
   return PointerType::get(FVTy, AddrSpace);
 }
 
 Value *VectorBlockGenerator::generateStrideOneLoad(
     ScopStmt &Stmt, LoadInst *Load, VectorValueMapT &ScalarMaps,
     __isl_keep isl_id_to_ast_expr *NewAccesses, bool NegativeStride = false) {
   unsigned VectorWidth = getVectorWidth();
   auto *Pointer = Load->getPointerOperand();
-  auto AS = Pointer->getType()->getPointerAddressSpace();
-  Type *VectorPtrType = getVectorPtrTy(Pointer, VectorWidth, AS);
+  Type *VectorPtrType = getVectorPtrTy(Pointer, VectorWidth);
   unsigned Offset = NegativeStride ? VectorWidth - 1 : 0;
 
   Value *NewPointer = generateLocationAccessed(Stmt, Load, ScalarMaps[Offset],
                                                VLTS[Offset], NewAccesses);
   Value *VectorPtr =
       Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
   LoadInst *VecLoad =
       Builder.CreateLoad(VectorPtr, Load->getName() + "_p_vec_full");
Value *VectorBlockGenerator::generateStrideOneLoad(
 
   return VecLoad;
 }
 
 Value *VectorBlockGenerator::generateStrideZeroLoad(
     ScopStmt &Stmt, LoadInst *Load, ValueMapT &BBMap,
     __isl_keep isl_id_to_ast_expr *NewAccesses) {
   auto *Pointer = Load->getPointerOperand();
-  auto AS = Pointer->getType()->getPointerAddressSpace();
-  Type *VectorPtrType = getVectorPtrTy(Pointer, 1, AS);
+  Type *VectorPtrType = getVectorPtrTy(Pointer, 1);
   Value *NewPointer =
       generateLocationAccessed(Stmt, Load, BBMap, VLTS[0], NewAccesses);
   Value *VectorPtr = Builder.CreateBitCast(NewPointer, VectorPtrType,
                                            Load->getName() + "_p_vec_p");
   LoadInst *ScalarLoad =
       Builder.CreateLoad(VectorPtr, Load->getName() + "_p_splat_one");
 
   if (!Aligned)
void VectorBlockGenerator::copyStore(
   Value *Vector = getVectorValue(Stmt, Store->getValueOperand(), VectorMap,
                                  ScalarMaps, getLoopForStmt(Stmt));
 
   // Make sure we have scalar values available to access the pointer to
   // the data location.
   extractScalarValues(Store, VectorMap, ScalarMaps);
 
   if (Access.isStrideOne(isl::manage_copy(Schedule))) {
-    auto AS = Pointer->getType()->getPointerAddressSpace();
-    Type *VectorPtrType = getVectorPtrTy(Pointer, getVectorWidth(), AS);
+    Type *VectorPtrType = getVectorPtrTy(Pointer, getVectorWidth());
     Value *NewPointer = generateLocationAccessed(Stmt, Store, ScalarMaps[0],
                                                  VLTS[0], NewAccesses);
 
     Value *VectorPtr =
         Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
     StoreInst *Store = Builder.CreateStore(Vector, VectorPtr);
 
     if (!Aligned)

 
 void VectorBlockGenerator::generateScalarVectorLoads(
     ScopStmt &Stmt, ValueMapT &VectorBlockMap) {
   for (MemoryAccess *MA : Stmt) {
     if (MA->isArrayKind() || MA->isWrite())
       continue;
 
     auto *Address = getOrCreateAlloca(*MA);
-    auto AS = Address->getType()->getPointerAddressSpace();
-    Type *VectorPtrType = getVectorPtrTy(Address, 1, AS);
+    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(
         FixedVectorType::get(Builder.getInt32Ty(), getVectorWidth()));
 
     Value *VectorVal = Builder.CreateShuffleVector(
         Val, Val, SplatVector, Address->getName() + "_p_splat");