[IRBuilder] Add utilities for materializing scalable values

[reames]

Summary

These idioms already appear a number of places in code, and upcoming changes to the various sanitizers continue to need more instances of the same patterns.

Posting this for review to gather feedback on the naming. I don't particularly like the names I chose, and am wondering if anyone has a better idea.

[paulwalker-arm]

llvm/include/llvm/IR/IRBuilder.h

898

I guess this is bike shedding but given IRBuilder has functions like getInt16() to return the IR form on a 16-bit integer value, how about just CreateElementCount that returns the IR form of ElementCount?

Not isolated to this patch but in general I dislike the use of runtime when naming things we've already named in order to allow for fixed length and scalable vectors. By which I mean I don't really consider CompileTimeElementCount/TypeSize as something that exists. But then perhaps I'm just being too picky :)

[luke]

llvm/include/llvm/IR/IRBuilder.h

898

+1, CreateElementCount makes sense to me.

[reames]

llvm/include/llvm/IR/IRBuilder.h

898

I'm going to take this naming suggestion and run with it. Seems reasonable to me as well.

llvm/include/llvm/IR/IRBuilder.h

public:
   /// Create a call to the experimental.gc.get.pointer.offset intrinsic to get
   /// the offset of the specified derived pointer from its base.
   CallInst *CreateGCGetPointerOffset(Value *DerivedPtr, const Twine &Name = "");
 
   /// Create a call to llvm.vscale, multiplied by \p Scaling. The type of VScale
   /// will be the same type as that of \p Scaling.
   Value *CreateVScale(Constant *Scaling, const Twine &Name = "");
 
+  /// Create an expression which evaluates to the number of elements in \p EC
+  /// at runtime.
+  Value *CreateElementCount(Type *DstType, ElementCount EC);
+
+  /// Create an expression which evaluates to the number of units in \p Size
+  /// at runtime.  This works for both units of bits and bytes.
+  Value *CreateTypeSize(Type *DstType, TypeSize Size);
+
   /// Creates a vector of type \p DstType with the linear sequence <0, 1, ...>
   Value *CreateStepVector(Type *DstType, const Twine &Name = "");
 
   /// Create a call to intrinsic \p ID with 1 operand which is mangled on its
   /// type.
   CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
                                  Instruction *FMFSource = nullptr,
                                  const Twine &Name = "");

llvm/lib/IR/IRBuilder.cpp

Value *IRBuilderBase::CreateVScale(Constant *Scaling, const Twine &Name) {
   Function *TheFn =
       Intrinsic::getDeclaration(M, Intrinsic::vscale, {Scaling->getType()});
   CallInst *CI = CreateCall(TheFn, {}, {}, Name);
   return cast<ConstantInt>(Scaling)->getSExtValue() == 1
              ? CI
              : CreateMul(CI, Scaling);
 }
 
+Value *IRBuilderBase::CreateElementCount(Type *DstType, ElementCount EC) {
+  Constant *MinEC = ConstantInt::get(DstType, EC.getKnownMinValue());
+  return EC.isScalable() ? CreateVScale(MinEC) : MinEC;
+}
+
+Value *IRBuilderBase::CreateTypeSize(Type *DstType, TypeSize Size) {
+  Constant *MinSize = ConstantInt::get(DstType, Size.getKnownMinValue());
+  return Size.isScalable() ? CreateVScale(MinSize) : MinSize;
+}
+
 Value *IRBuilderBase::CreateStepVector(Type *DstType, const Twine &Name) {
   Type *STy = DstType->getScalarType();
   if (isa<ScalableVectorType>(DstType)) {
     Type *StepVecType = DstType;
     // TODO: We expect this special case (element type < 8 bits) to be
     // temporary - once the intrinsic properly supports < 8 bits this code
     // can be removed.
     if (STy->getScalarSizeInBits() < 8)

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (auto *SplatValue = getSplatValue(II.getArgOperand(0))) {
       return S;
     }
     // scatter(vector, splat(ptr), splat(true)) -> store extract(vector,
     // lastlane), ptr
     if (ConstMask->isAllOnesValue()) {
       Align Alignment = cast<ConstantInt>(II.getArgOperand(2))->getAlignValue();
       VectorType *WideLoadTy = cast<VectorType>(II.getArgOperand(1)->getType());
       ElementCount VF = WideLoadTy->getElementCount();
-      Constant *EC =
-          ConstantInt::get(Builder.getInt32Ty(), VF.getKnownMinValue());
-      Value *RunTimeVF = VF.isScalable() ? Builder.CreateVScale(EC) : EC;
+      Value *RunTimeVF = Builder.CreateElementCount(Builder.getInt32Ty(), VF);
       Value *LastLane = Builder.CreateSub(RunTimeVF, Builder.getInt32(1));
       Value *Extract =
           Builder.CreateExtractElement(II.getArgOperand(0), LastLane);
       StoreInst *S =
           new StoreInst(Extract, SplatPtr, /*IsVolatile=*/false, Alignment);
       S->copyMetadata(II);
       return S;
     }

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

for (unsigned Idx = 0; Idx < Num; ++Idx) {
                           Granularity, ElemTypeSize, IsWrite,
                           SizeArgument, UseCalls, Exp);
     }
     return;
   }
 
 
   IRBuilder<> IRB(I);
-  Constant *MinNumElem =
-    ConstantInt::get(IntptrTy, VTy->getElementCount().getKnownMinValue());
-  assert(isa<ScalableVectorType>(VTy) && "generalize if reused for fixed length");
-  Value *NumElements = IRB.CreateVScale(MinNumElem);
+  Value *NumElements = IRB.CreateElementCount(IntptrTy, VTy->getElementCount());
 
   Instruction *BodyIP;
   Value *Index;
   SplitBlockAndInsertSimpleForLoop(NumElements, I, BodyIP, Index);
 
   IRB.SetInsertPoint(BodyIP);
   Value *MaskElem = IRB.CreateExtractElement(Mask, Index);
   Instruction *ThenTerm = SplitBlockAndInsertIfThen(MaskElem, BodyIP, false);

 // Instrument unusual size or unusual alignment.
 // We can not do it with a single check, so we do 1-byte check for the first
 // and the last bytes. We call __asan_report_*_n(addr, real_size) to be able
 // to report the actual access size.
 void AddressSanitizer::instrumentUnusualSizeOrAlignment(
     Instruction *I, Instruction *InsertBefore, Value *Addr, TypeSize TypeStoreSize,
     bool IsWrite, Value *SizeArgument, bool UseCalls, uint32_t Exp) {
   IRBuilder<> IRB(InsertBefore);
-  Constant *MinBits =
-    ConstantInt::get(IntptrTy, TypeStoreSize.getKnownMinValue());
-  Value *NumBits =
-    !TypeStoreSize.isScalable() ? MinBits : IRB.CreateVScale(MinBits);
+  Value *NumBits = IRB.CreateTypeSize(IntptrTy, TypeStoreSize);
   Value *Size = IRB.CreateLShr(NumBits, ConstantInt::get(IntptrTy, 3));
 
   Value *AddrLong = IRB.CreatePointerCast(Addr, IntptrTy);
   if (UseCalls) {
     if (Exp == 0)
       IRB.CreateCall(AsanMemoryAccessCallbackSized[IsWrite][0],
                      {AddrLong, Size});
     else

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

 }
 
 namespace llvm {
 
 /// Return a value for Step multiplied by VF.
 Value *createStepForVF(IRBuilderBase &B, Type *Ty, ElementCount VF,
                        int64_t Step) {
   assert(Ty->isIntegerTy() && "Expected an integer step");
-  Constant *StepVal = ConstantInt::get(Ty, Step * VF.getKnownMinValue());
-  return VF.isScalable() ? B.CreateVScale(StepVal) : StepVal;
+  return B.CreateElementCount(Ty, VF.multiplyCoefficientBy(Step));
 }
 
 /// Return the runtime value for VF.
 Value *getRuntimeVF(IRBuilderBase &B, Type *Ty, ElementCount VF) {
-  Constant *EC = ConstantInt::get(Ty, VF.getKnownMinValue());
-  return VF.isScalable() ? B.CreateVScale(EC) : EC;
+  return B.CreateElementCount(Ty, VF);
 }
 
 const SCEV *createTripCountSCEV(Type *IdxTy, PredicatedScalarEvolution &PSE) {
   const SCEV *BackedgeTakenCount = PSE.getBackedgeTakenCount();
   assert(!isa<SCEVCouldNotCompute>(BackedgeTakenCount) && "Invalid loop count");
 
   ScalarEvolution &SE = *PSE.getSE();