[mlir][nfc] Add a func to compute numElements of a shape in Std -> LLVM.

[pifon2a]

Summary

For some reason the variable cumulativeSizeInBytes in
getCumulativeSizeInBytes was actually storing number of elements. I decided
to fix it and refactor the function a bit.

[pifon2a]

Restore the computation order.

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

void getMemRefDescriptorSizes(Location loc, MemRefType memRefType,
                                 ArrayRef<Value> dynSizes,
                                 ConversionPatternRewriter &rewriter,
                                 SmallVectorImpl<Value> &sizes) const;
 
   /// Computes the size of type in bytes.
   Value getSizeInBytes(Location loc, Type type,
                        ConversionPatternRewriter &rewriter) const;
 
+  /// Computes total number of elements for the given shape.
+  Value getNumElements(Location loc, ArrayRef<Value> shape,
+                       ConversionPatternRewriter &rewriter) const;
+
   /// Computes total size in bytes of to store the given shape.
   Value getCumulativeSizeInBytes(Location loc, Type elementType,
                                  ArrayRef<Value> shape,
                                  ConversionPatternRewriter &rewriter) const;
 
   /// Creates and populates the memref descriptor struct given all its fields.
   /// 'strides' can be either dynamic (kDynamicStrideOrOffset) or static, but
   /// not a mix of the two.

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

auto convertedPtrType =
       typeConverter.convertType(type).cast<LLVM::LLVMType>().getPointerTo();
   auto nullPtr = rewriter.create<LLVM::NullOp>(loc, convertedPtrType);
   auto gep = rewriter.create<LLVM::GEPOp>(
       loc, convertedPtrType,
       ArrayRef<Value>{nullPtr, createIndexConstant(rewriter, loc, 1)});
   return rewriter.create<LLVM::PtrToIntOp>(loc, getIndexType(), gep);
 }
 
-Value ConvertToLLVMPattern::getCumulativeSizeInBytes(
-    Location loc, Type elementType, ArrayRef<Value> shape,
+Value ConvertToLLVMPattern::getNumElements(
+    Location loc, ArrayRef<Value> shape,
     ConversionPatternRewriter &rewriter) const {
   // Compute the total number of memref elements.
-  Value cumulativeSizeInBytes =
+  Value numElements =
       shape.empty() ? createIndexConstant(rewriter, loc, 1) : shape.front();
   for (unsigned i = 1, e = shape.size(); i < e; ++i)
-    cumulativeSizeInBytes = rewriter.create<LLVM::MulOp>(
-        loc, getIndexType(), ArrayRef<Value>{cumulativeSizeInBytes, shape[i]});
-  auto elementSize = this->getSizeInBytes(loc, elementType, rewriter);
-  return rewriter.create<LLVM::MulOp>(
-      loc, getIndexType(), ArrayRef<Value>{cumulativeSizeInBytes, elementSize});
+    numElements = rewriter.create<LLVM::MulOp>(loc, numElements, shape[i]);
+  return numElements;
+}
+
+Value ConvertToLLVMPattern::getCumulativeSizeInBytes(
+    Location loc, Type elementType, ArrayRef<Value> shape,
+    ConversionPatternRewriter &rewriter) const {
+  Value elementSize = this->getSizeInBytes(loc, elementType, rewriter);
+  Value numElements = this->getNumElements(loc, shape, rewriter);
+  return rewriter.create<LLVM::MulOp>(loc, numElements, elementSize);
 }
 
 /// Creates and populates the memref descriptor struct given all its fields.
 MemRefDescriptor ConvertToLLVMPattern::createMemRefDescriptor(
     Location loc, MemRefType memRefType, Value allocatedPtr, Value alignedPtr,
     uint64_t offset, ArrayRef<int64_t> strides, ArrayRef<Value> sizes,
     ConversionPatternRewriter &rewriter) const {
   auto structType = typeConverter.convertType(memRefType);