[flang] Fix handling of elem_len in CFI_establish

[rovka]

Summary

The current code computes the minimum element length based on the type
used to create the descriptor and uses that as the element length
whenever it is greater than 0. This means that the elem_len parameter
is essentially ignored for any type where we can compute a minimum
element length (which includes CFI_type_char[16|32]_t), and we may
therefore end up with descriptors with a lower element length than
expected.

This patch fixes the issue by explicitly doing what the standard says,
i.e. it uses the given elem_len for character types, CFI_type_struct
and CFI_type_other, and ignores it (falls back to the minimum element
length) for everything else.

flang/runtime/ISO_Fortran_binding.cpp

if (rank > 0 && base_addr && !extents) {
     return CFI_INVALID_EXTENT;
   }
   if (type < CFI_type_signed_char || type > CFI_TYPE_LAST) {
     return CFI_INVALID_TYPE;
   }
   if (!descriptor) {
     return CFI_INVALID_DESCRIPTOR;
   }
-  std::size_t minElemLen{MinElemLen(type)};
-  if (minElemLen > 0) {
-    elem_len = minElemLen;
-  } else if (elem_len <= 0) {
+  if (type == CFI_type_struct || type == CFI_type_other ||
+      IsCharacterType(type)) {
+    if (elem_len <= 0)
       return CFI_INVALID_ELEM_LEN;
+  } else {
+    elem_len = MinElemLen(type);
+    assert(elem_len > 0 && "Unknown element length for type");
   }
   descriptor->base_addr = base_addr;
   descriptor->elem_len = elem_len;
   descriptor->version = CFI_VERSION;
   descriptor->rank = rank;
   descriptor->type = type;
   descriptor->attribute = attribute;
   descriptor->f18Addendum = 0;

flang/unittests/Evaluate/ISO-Fortran-binding.cpp

if (retCode == CFI_SUCCESS) {
     if (attribute == CFI_attribute_pointer) {
       if (base_addr != nullptr) {
         for (int i{0}; i < rank; ++i) {
           MATCH(0, res->GetDimension(i).LowerBound());
         }
       }
     }
     if (type == CFI_type_struct || type == CFI_type_char ||
+        type == CFI_type_char16_t || type == CFI_type_char32_t ||
         type == CFI_type_other) {
       MATCH(elem_len, res->ElementBytes());
     }
   }
   // Checking failure/success according to combination of args forbidden by the
   // standard:
   int numErr{0};
   int expectedRetCode{CFI_SUCCESS};
   if (base_addr != nullptr && attribute == CFI_attribute_allocatable) {
     ++numErr;
     expectedRetCode = CFI_ERROR_BASE_ADDR_NOT_NULL;
   }
   if (rank > CFI_MAX_RANK) {
     ++numErr;
     expectedRetCode = CFI_INVALID_RANK;
   }
   if (type < 0 || type > CFI_TYPE_LAST) {
     ++numErr;
     expectedRetCode = CFI_INVALID_TYPE;
   }
 
   if ((type == CFI_type_struct || type == CFI_type_char ||
+          type == CFI_type_char16_t || type == CFI_type_char32_t ||
           type == CFI_type_other) &&
       elem_len <= 0) {
     ++numErr;
     expectedRetCode = CFI_INVALID_ELEM_LEN;
   }
   if (rank > 0 && base_addr != nullptr && extents == nullptr) {
     ++numErr;
     expectedRetCode = CFI_INVALID_EXTENT;
static void run_CFI_establish_tests() {
   CFI_CDESC_T(CFI_MAX_RANK) dv_storage;
   CFI_cdesc_t *dv{&dv_storage};
   char base;
   void *dummyAddr{&base};
   // Define test space
   CFI_attribute_t attrCases[]{
       CFI_attribute_pointer, CFI_attribute_allocatable, CFI_attribute_other};
   CFI_type_t typeCases[]{CFI_type_int, CFI_type_struct, CFI_type_double,
-      CFI_type_char, CFI_type_other, CFI_TYPE_LAST + 1};
+      CFI_type_char, CFI_type_char16_t, CFI_type_char32_t, CFI_type_other,
+      CFI_TYPE_LAST + 1};
   CFI_index_t *extentCases[]{extents, nullptr};
   void *baseAddrCases[]{dummyAddr, nullptr};
   CFI_rank_t rankCases[]{0, 1, CFI_MAX_RANK, CFI_MAX_RANK + 1};
   std::size_t lenCases[]{0, 42};
 
   for (CFI_attribute_t attribute : attrCases) {
     for (void *base_addr : baseAddrCases) {
       for (CFI_index_t *extent : extentCases) {