[WIP][Flang][OpenMP] Fix for SWDEV-540203 and other character array issues

This PR addresses the problem where we generate an incorrect GEP due to
Flang providing a slightly incorrect type.

It also fixes a few issues with the size calculation caused by similar
issues, primarily the bounds and type being slightly off of what would
be expected for both regular char arrays and allocatable char arrays.

So this should fix 3 isuses with character array mapping in Flang.

I've marked it as WIP as I'd like to look at an alternative fix at a
higher level than the OpenMPToLLVMIRTranslation phase, but this fix
works and doesn't break any local map tests, so it'll be the fix if
my idea doesn't work out or the fixes are needed urgently!

Author: agozillon

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

@@ -3532,13 +3532,36 @@ static TargetDirective getTargetDirectiveFromOp(Operation *op) {
 
 } // namespace
 
-uint64_t getArrayElementSizeInBits(LLVM::LLVMArrayType arrTy, DataLayout &dl) {
+// In certain cases, we can be provided less bounds than there are nested array
+// types, but still be provided bounds, in these cases we try to compute the
+// size up to the point of the bounds provided and then let the bounds x size
+// computation do the rest of the work. This is most common in Flang where
+// character arrays provided character lengths (C/C++ string esque), represent
+// the internal string as a byte array with the length of this string
+// unrepresented by bounds.
+uint64_t getArrayElementSizeInBits(LLVM::LLVMArrayType arrTy, DataLayout &dl,
+                                   int boundsCount) {
+  if (boundsCount == 0)
+    return dl.getTypeSizeInBits(arrTy);
   if (auto nestedArrTy = llvm::dyn_cast_if_present<LLVM::LLVMArrayType>(
           arrTy.getElementType()))
-    return getArrayElementSizeInBits(nestedArrTy, dl);
+    return getArrayElementSizeInBits(nestedArrTy, dl, --boundsCount);
   return dl.getTypeSizeInBits(arrTy.getElementType());
 }
 
+// It is possible for a 1-D array type to provide N-D bounds to index
+// with instead of 1-D Bounds. this is common to do with byte arrays
+// that are representing other data types, e.g. an N-D char array, we
+// support this use case.
+// TODO: Extend to just check if we have more bounds than array
+// dimensions
+static bool is1DArrayWithNDBounds(llvm::Type *type, size_t numBounds) {
+  if (type->isArrayTy() && !type->getArrayElementType()->isArrayTy() &&
+      numBounds > 1)
+    return true;
+  return false;
+}
+
 // This function calculates the size to be offloaded for a specified type, given
 // its associated map clause (which can contain bounds information which affects
 // the total size), this size is calculated based on the underlying element type
@@ -3553,6 +3576,8 @@ llvm::Value *getSizeInBytes(DataLayout &dl, const mlir::Type &type,
                             Operation *clauseOp, llvm::Value *basePointer,
                             llvm::Type *baseType, llvm::IRBuilderBase &builder,
                             LLVM::ModuleTranslation &moduleTranslation) {
+  // TODO: If the array is provably constant sized (e.g. from the type), work
+  // out constant size from the type and skip the calculation from the bounds.
   if (auto memberClause =
           mlir::dyn_cast_if_present<mlir::omp::MapInfoOp>(clauseOp)) {
     // This calculates the size to transfer based on bounds and the underlying
@@ -3582,7 +3607,10 @@ llvm::Value *getSizeInBytes(DataLayout &dl, const mlir::Type &type,
       // the size in inconsistent byte or bit format.
       uint64_t underlyingTypeSzInBits = dl.getTypeSizeInBits(type);
       if (auto arrTy = llvm::dyn_cast_if_present<LLVM::LLVMArrayType>(type))
-        underlyingTypeSzInBits = getArrayElementSizeInBits(arrTy, dl);
+        if (!is1DArrayWithNDBounds(moduleTranslation.convertType(type),
+                                   memberClause.getBounds().size()))
+          underlyingTypeSzInBits = getArrayElementSizeInBits(
+              arrTy, dl, memberClause.getBounds().size());
 
       // The size in bytes x number of elements, the sizeInBytes stored is
       // the underyling types size, e.g. if ptr<i32>, it'll be the i32's
@@ -4415,7 +4443,10 @@ createAlteredByCaptureMap(MapInfoData &mapData,
       case omp::VariableCaptureKind::ByRef: {
         llvm::Value *newV = mapData.Pointers[i];
         std::vector<llvm::Value *> offsetIdx = calculateBoundsOffset(
-            moduleTranslation, builder, mapData.BaseType[i]->isArrayTy(),
+            moduleTranslation, builder,
+            mapData.BaseType[i]->isArrayTy() &&
+                !is1DArrayWithNDBounds(mapData.BaseType[i],
+                                       mapOp.getBounds().size()),
             mapOp.getBounds());
         if (isPtrTy)
           newV = builder.CreateLoad(builder.getPtrTy(), newV);