[flang] "CFI" types for Fortran REAL and COMPLEX kinds 2, 3, 10, 16

[vdonaldson]

Summary

Add additional "CFI" types for Fortran REAL and COMPLEX kinds 2, 3, 10, 16 to allow their use in Fortran descriptors.

[vdonaldson]

https://reviews.llvm.org/D117336

flang/include/flang/ISO_Fortran_binding.h

 typedef unsigned char CFI_attribute_t;
 #define CFI_attribute_pointer 1
 #define CFI_attribute_allocatable 2
 #define CFI_attribute_other 0 /* neither pointer nor allocatable */
 
 typedef signed char CFI_type_t;
 /* These codes are required to be macros (i.e., #ifdef will work).
  * They are not required to be distinct, but neither are they required
- * to have had their synonyms combined.
+ * to have had their synonyms combined.  Codes marked as extensions may be
+ * place holders for as yet unimplemented types.
  */
 #define CFI_type_signed_char 1
 #define CFI_type_short 2
 #define CFI_type_int 3
 #define CFI_type_long 4
 #define CFI_type_long_long 5
 #define CFI_type_size_t 6
 #define CFI_type_int8_t 7
 #define CFI_type_int16_t 8
 #define CFI_type_int32_t 9
 #define CFI_type_int64_t 10
 #define CFI_type_int128_t 11 /* extension */
 #define CFI_type_int_least8_t 12
 #define CFI_type_int_least16_t 13
 #define CFI_type_int_least32_t 14
 #define CFI_type_int_least64_t 15
-#define CFI_type_int_least128_t 16
+#define CFI_type_int_least128_t 16 /* extension */
 #define CFI_type_int_fast8_t 17
 #define CFI_type_int_fast16_t 18
 #define CFI_type_int_fast32_t 19
 #define CFI_type_int_fast64_t 20
-#define CFI_type_int_fast128_t 21
+#define CFI_type_int_fast128_t 21 /* extension */
 #define CFI_type_intmax_t 22
 #define CFI_type_intptr_t 23
 #define CFI_type_ptrdiff_t 24
-#define CFI_type_float 25
-#define CFI_type_double 26
-#define CFI_type_long_double 27
-#define CFI_type_float_Complex 28
-#define CFI_type_double_Complex 29
-#define CFI_type_long_double_Complex 30
-#define CFI_type_Bool 31
-#define CFI_type_char 32
-#define CFI_type_cptr 33
-#define CFI_type_struct 34
-#define CFI_type_char16_t 35 /* extension: char16_t */
-#define CFI_type_char32_t 36 /* extension: char32_t */
+#define CFI_type_half_float 25 /* extension: kind=2 */
+#define CFI_type_bfloat 26 /* extension: kind=3 */
+#define CFI_type_float 27
+#define CFI_type_double 28
+#define CFI_type_extended_double 29 /* extension: kind=10 */
+#define CFI_type_long_double 30
+#define CFI_type_float128 31 /* extension: kind=16 */
+#define CFI_type_half_float_Complex 32 /* extension: kind=2 */
+#define CFI_type_bfloat_Complex 33 /* extension: kind=3 */
+#define CFI_type_float_Complex 34
+#define CFI_type_double_Complex 35
+#define CFI_type_extended_double_Complex 36 /* extension: kind=10 */
+#define CFI_type_long_double_Complex 37
+#define CFI_type_float128_Complex 38 /* extension: kind=16 */
+#define CFI_type_Bool 39
+#define CFI_type_char 40
+#define CFI_type_cptr 41
+#define CFI_type_struct 42
+#define CFI_type_char16_t 43 /* extension */
+#define CFI_type_char32_t 44 /* extension */
 #define CFI_TYPE_LAST CFI_type_char32_t
 #define CFI_type_other (-1) // must be negative
 
 /* Error code macros - skip some of the small values to avoid conflicts with
  * other status codes mandated by the standard, e.g. those returned by
  * GET_ENVIRONMENT_VARIABLE (16.9.84) */
 #define CFI_SUCCESS 0 /* must be zero */
 #define CFI_ERROR_BASE_ADDR_NULL 11

flang/include/flang/Runtime/type-code.h

public:
 
   constexpr bool IsValid() const {
     return raw_ >= CFI_type_signed_char && raw_ <= CFI_TYPE_LAST;
   }
   constexpr bool IsInteger() const {
     return raw_ >= CFI_type_signed_char && raw_ <= CFI_type_ptrdiff_t;
   }
   constexpr bool IsReal() const {
-    return raw_ >= CFI_type_float && raw_ <= CFI_type_long_double;
+    return raw_ >= CFI_type_half_float && raw_ <= CFI_type_float128;
   }
   constexpr bool IsComplex() const {
-    return raw_ >= CFI_type_float_Complex &&
-        raw_ <= CFI_type_long_double_Complex;
+    return raw_ >= CFI_type_half_float_Complex &&
+        raw_ <= CFI_type_float128_Complex;
   }
   constexpr bool IsCharacter() const {
     return raw_ == CFI_type_char || raw_ == CFI_type_char16_t ||
         raw_ == CFI_type_char32_t;
   }
   constexpr bool IsLogical() const {
     return raw_ == CFI_type_Bool ||
         (raw_ >= CFI_type_int_least8_t && raw_ <= CFI_type_int_least64_t);

flang/runtime/ISO_Fortran_binding.cpp

case CFI_type_intmax_t:
     minElemLen = sizeof(std::intmax_t);
     break;
   case CFI_type_intptr_t:
     minElemLen = sizeof(std::intptr_t);
     break;
   case CFI_type_ptrdiff_t:
     minElemLen = sizeof(std::ptrdiff_t);
     break;
+  case CFI_type_half_float:
+    minElemLen = 2;
+    break;
+  case CFI_type_bfloat:
+    minElemLen = 2;
+    break;
   case CFI_type_float:
     minElemLen = sizeof(float);
     break;
   case CFI_type_double:
     minElemLen = sizeof(double);
     break;
+  case CFI_type_extended_double:
+    minElemLen = 10;
+    break;
   case CFI_type_long_double:
     minElemLen = sizeof(long double);
     break;
+  case CFI_type_float128:
+    minElemLen = 16;
+    break;
+  case CFI_type_half_float_Complex:
+    minElemLen = 2 * MinElemLen(CFI_type_half_float);
+    break;
+  case CFI_type_bfloat_Complex:
+    minElemLen = 2 * MinElemLen(CFI_type_bfloat);
+    break;
   case CFI_type_float_Complex:
     minElemLen = 2 * sizeof(float);
     break;
   case CFI_type_double_Complex:
     minElemLen = 2 * sizeof(double);
     break;
+  case CFI_type_extended_double_Complex:
+    minElemLen = 2 * MinElemLen(CFI_type_extended_double);
+    break;
   case CFI_type_long_double_Complex:
     minElemLen = 2 * sizeof(long double);
     break;
+  case CFI_type_float128_Complex:
+    minElemLen = 2 * MinElemLen(CFI_type_float128);
+    break;
   case CFI_type_Bool:
     minElemLen = 1;
     break;
   case CFI_type_cptr:
     minElemLen = sizeof(void *);
     break;
   case CFI_type_char16_t:
     minElemLen = sizeof(char16_t);

flang/runtime/type-code.cpp

case 8:
       break;
     case 16:
       raw_ = CFI_type_int128_t;
       break;
     }
     break;
   case TypeCategory::Real:
     switch (kind) {
+    case 2:
+      raw_ = CFI_type_half_float;
+      break;
+    case 3:
+      raw_ = CFI_type_bfloat;
+      break;
     case 4:
       raw_ = CFI_type_float;
       break;
     case 8:
       raw_ = CFI_type_double;
       break;
     case 10:
+      raw_ = CFI_type_extended_double;
+      break;
     case 16:
-      raw_ = CFI_type_long_double;
+      raw_ = CFI_type_float128;
       break;
     }
     break;
   case TypeCategory::Complex:
     switch (kind) {
     case 4:
       raw_ = CFI_type_float_Complex;
       break;
TypeCode::GetCategoryAndKind() const {
   case CFI_type_int16_t:
     return std::make_pair(TypeCategory::Integer, 2);
   case CFI_type_int32_t:
     return std::make_pair(TypeCategory::Integer, 4);
   case CFI_type_int64_t:
     return std::make_pair(TypeCategory::Integer, 8);
   case CFI_type_int128_t:
     return std::make_pair(TypeCategory::Integer, 16);
+  case CFI_type_half_float:
+    return std::make_pair(TypeCategory::Real, 2);
+  case CFI_type_bfloat:
+    return std::make_pair(TypeCategory::Real, 3);
   case CFI_type_float:
     return std::make_pair(TypeCategory::Real, 4);
   case CFI_type_double:
     return std::make_pair(TypeCategory::Real, 8);
+  case CFI_type_extended_double:
+    return std::make_pair(TypeCategory::Real, 10);
   case CFI_type_long_double:
 #if __x86_64__
     return std::make_pair(TypeCategory::Real, 10);
 #else
     return std::make_pair(TypeCategory::Real, 16);
 #endif
+  case CFI_type_float128:
+    return std::make_pair(TypeCategory::Real, 16);
+  case CFI_type_half_float_Complex:
+    return std::make_pair(TypeCategory::Complex, 2);
+  case CFI_type_bfloat_Complex:
+    return std::make_pair(TypeCategory::Complex, 3);
   case CFI_type_float_Complex:
     return std::make_pair(TypeCategory::Complex, 4);
   case CFI_type_double_Complex:
     return std::make_pair(TypeCategory::Complex, 8);
+  case CFI_type_extended_double_Complex:
+    return std::make_pair(TypeCategory::Complex, 10);
   case CFI_type_long_double_Complex:
 #if __x86_64__
     return std::make_pair(TypeCategory::Complex, 10);
 #else
     return std::make_pair(TypeCategory::Complex, 16);
 #endif
+  case CFI_type_float128_Complex:
+    return std::make_pair(TypeCategory::Complex, 16);
   case CFI_type_char:
     return std::make_pair(TypeCategory::Character, 1);
   case CFI_type_char16_t:
     return std::make_pair(TypeCategory::Character, 2);
   case CFI_type_char32_t:
     return std::make_pair(TypeCategory::Character, 4);
   case CFI_type_Bool:
     return std::make_pair(TypeCategory::Logical, 1);

flang/test/Fir/convert-to-llvm.fir

 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<i64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 func @embox_typecode1(%arg0: !fir.ref<f32>) {
   %0 = fir.embox %arg0 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode1
-// CHECK: %[[TYPE_CODE_F32:.*]] = llvm.mlir.constant(25 : i32) : i32
+// CHECK: %[[TYPE_CODE_F32:.*]] = llvm.mlir.constant(27 : i32) : i32
 // CHECK: %[[TYPE_CODE_F32_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F32_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 func @embox_typecode2(%arg0: !fir.ref<f128>) {
   %0 = fir.embox %arg0 : (!fir.ref<f128>) -> !fir.box<!fir.ptr<f128>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode2
-// CHECK: %[[TYPE_CODE_F128:.*]] = llvm.mlir.constant(27 : i32) : i32
+// CHECK: %[[TYPE_CODE_F128:.*]] = llvm.mlir.constant(30 : i32) : i32
 // CHECK: %[[TYPE_CODE_F128_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F128_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<f128>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 func @embox_typecode3(%arg0: !fir.ref<!fir.complex<4>>) {
   %0 = fir.embox %arg0 : (!fir.ref<!fir.complex<4>>) -> !fir.box<!fir.ptr<!fir.complex<4>>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode3
-// CHECK: %[[TYPE_CODE_CPLX4:.*]] = llvm.mlir.constant(28 : i32) : i32
+// CHECK: %[[TYPE_CODE_CPLX4:.*]] = llvm.mlir.constant(34 : i32) : i32
 // CHECK: %[[TYPE_CODE_CPLX4_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_CPLX4_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<struct<(f32, f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 func @embox_typecode4(%arg0: !fir.ref<!fir.logical<1>>) {
   %0 = fir.embox %arg0 : (!fir.ref<!fir.logical<1>>) -> !fir.box<!fir.ptr<!fir.logical<1>>>
   return
 }
 
 // CHECK-LABEL: llvm.func @embox_typecode4
-// CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(31 : i32) : i32
+// CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(39 : i32) : i32
 // CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
 // CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<i8>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
 
 // -----
 
 // Test `fir.embox` conversion. This test creates a global so it needs to be
 // split from others.
 
 // Check descriptor for a derived type. Check that the f18Addendum flag is set
 // to 1 meaning the addendum is present (true) and the addendum values are
 // inserted.
 
 func @embox1(%arg0: !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) {
   %0 = fir.embox %arg0() : (!fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTtseq{i:i32}>>
   return
 }
 
 // CHECK: llvm.mlir.global extern_weak @_QMtest_dinitE.dt.tseq() : i8
 // CHECK-LABEL: llvm.func @embox1
-// CHECK:         %[[TYPE_CODE:.*]] = llvm.mlir.constant(34 : i32) : i32
+// CHECK:         %[[TYPE_CODE:.*]] = llvm.mlir.constant(42 : i32) : i32
 // CHECK:         %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8
 // CHECK:         %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
 // CHECK:         %[[F18ADDENDUM:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8
 // CHECK:         %{{.*}} = llvm.insertvalue %[[F18ADDENDUM_I8]], %18[6 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
 // CHECK:         %[[TDESC:.*]] = llvm.mlir.addressof @_QMtest_dinitE.dt.tseq : !llvm.ptr<i8>
 // CHECK:         %[[TDESC_CAST:.*]] = llvm.bitcast %22 : !llvm.ptr<i8> to !llvm.ptr<i8>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[TDESC_CAST]], %{{.*}}[7 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>

 // CHECK:         %[[N2_TMP:.*]] = llvm.sub %[[N]], %[[SH2]]  : i64
 // CHECK:         %[[N2:.*]] = llvm.add %[[N2_TMP]], %[[C1]]  : i64
 // CHECK:         %[[C1_0:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:         %[[ARR_SIZE_TMP1:.*]] = llvm.mul %[[C1_0]], %[[N1]]  : i64
 // CHECK:         %[[ARR_SIZE:.*]] = llvm.mul %[[ARR_SIZE_TMP1]], %[[N2]]  : i64
 // CHECK:         %[[ARR:.*]] = llvm.alloca %[[ARR_SIZE]] x f64 {bindc_name = "arr", in_type = !fir.array<?x?xf64>, operand_segment_sizes = dense<[0, 2]> : vector<2xi32>, uniq_name = "_QFsbEarr"} : (i64) -> !llvm.ptr<f64>
 // CHECK:         %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
 // CHECK:         %[[ELEM_LEN:.*]] = llvm.mlir.constant(8 : i32) : i32
-// CHECK:         %[[TYPE_CODE:.*]] = llvm.mlir.constant(26 : i32) : i32
+// CHECK:         %[[TYPE_CODE:.*]] = llvm.mlir.constant(28 : i32) : i32
 // CHECK:         %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64
 // CHECK:         %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1 : i32] : !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
 // CHECK:         %[[VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32
 // CHECK:         %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2 : i32] : !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
 // CHECK:         %[[RANK:.*]] = llvm.mlir.constant(2 : i32) : i32
 // CHECK:         %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8
 // CHECK:         %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3 : i32] : !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
 // CHECK:         %[[TYPE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8

 //CHECK:    %[[RESULT_BOX_REF:.*]] = llvm.alloca %[[ONE_1]] x !llvm.struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>
 //CHECK:    %[[THREE:.*]] = llvm.mlir.constant(3 : index) : i64
 //CHECK:    %[[FOUR:.*]] = llvm.mlir.constant(4 : index) : i64
 //CHECK:    %[[FIVE:.*]] = llvm.mlir.constant(5 : index) : i64
 //CHECK:    %[[SIX:.*]] = llvm.mlir.constant(6 : index) : i64
 //CHECK:    %[[EIGHTY:.*]] = llvm.mlir.constant(80 : index) : i64
 //CHECK:    %[[RBOX:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:    %[[ELEM_SIZE:.*]] = llvm.mlir.constant(4 : i32) : i32
-//CHECK:    %[[FLOAT_TYPE:.*]] = llvm.mlir.constant(25 : i32) : i32
+//CHECK:    %[[FLOAT_TYPE:.*]] = llvm.mlir.constant(27 : i32) : i32
 //CHECK:    %[[ELEM_SIZE_I64:.*]] = llvm.sext %[[ELEM_SIZE]] : i32 to i64
 //CHECK:    %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE_I64]], %[[RBOX]][1 : i32] : !llvm.struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:    %[[CFI_VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32
 //CHECK:    %[[RBOX_TMP2:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[RBOX_TMP1]][2 : i32] : !llvm.struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:    %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32
 //CHECK:    %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8
 //CHECK:    %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3 : i32] : !llvm.struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:    %[[FLOAT_TYPE_I8:.*]] = llvm.trunc %[[FLOAT_TYPE]] : i32 to i8

 //CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<struct<"t", (i32, array<10 x i8>)>>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr<i8>, array<1 x i64>)>>
 //CHECK:   %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
 //CHECK:   %[[RESULT_BOX_REF:.*]] = llvm.alloca %[[ONE]] x !llvm.struct<(ptr<i8>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<(ptr<i8>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>
 //CHECK:   %[[RESULT_LB:.*]] = llvm.mlir.constant(3 : i64) : i64
 //CHECK:   %[[RESULT_UB:.*]] = llvm.mlir.constant(60 : i64) : i64
 //CHECK:   %[[RESULT_STRIDE:.*]] = llvm.mlir.constant(9 : i64) : i64
 //CHECK:   %[[COMPONENT_OFFSET_1:.*]] = llvm.mlir.constant(1 : i64) : i64
 //CHECK:   %[[ELEM_SIZE:.*]] = llvm.mlir.constant(7 : i64) : i64
-//CHECK:   %[[TYPE_CHAR:.*]] = llvm.mlir.constant(32 : i32) : i32
+//CHECK:   %[[TYPE_CHAR:.*]] = llvm.mlir.constant(40 : i32) : i32
 //CHECK:   %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE]], %{{.*}}[1 : i32] : !llvm.struct<(ptr<i8>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:   %[[RBOX_TMP2:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP1]][2 : i32] : !llvm.struct<(ptr<i8>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:   %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32
 //CHECK:   %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8
 //CHECK:   %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3 : i32] : !llvm.struct<(ptr<i8>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:   %[[TYPE_CHAR_I8:.*]] = llvm.trunc %[[TYPE_CHAR]] : i32 to i8
 //CHECK:   %[[RBOX_TMP4:.*]] = llvm.insertvalue %[[TYPE_CHAR_I8]], %[[RBOX_TMP3]][4 : i32] : !llvm.struct<(ptr<i8>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
 //CHECK:   %[[RBOX_TMP5:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP4]][5 : i32] : !llvm.struct<(ptr<i8>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>