Add support for standard IFC fixed-width floating-point types [GH #409]

Author: soroshsabz

src/ifc_modules_read.c

@@ -16497,8 +16497,30 @@ no corresponding type, return an error type.
             }
             break;
           case ifc_tbs_float:
-            check_assertion(precision == ifc_tps_default);
-            result = float_type((a_float_kind)fk_float);
+            switch (precision) {
+              case ifc_tps_default:
+                result = float_type(fk_float);
+                break;
+              case ifc_tps_bit16:
+                result = float_type(float16_kind());
+                break;
+              case ifc_tps_bit32:
+                result = float_type(fk_std_float32);
+                break;
+              case ifc_tps_bit64:
+                result = float_type(fk_std_float64);
+                break;
+              case ifc_tps_bit128:
+                result = float_type(fk_std_float128);
+                break;
+              default:
+                { a_string err_msg("Unexpected ", str_for(precision),
+                                   " for ", str_for(basis));
+
+                  ifc_unexpected(module_of(itf), err_msg);
+                }
+                goto invalid;
+            }  /* switch */
             break;
           case ifc_tbs_double:
             if (precision == ifc_tps_long) {
@@ -24588,8 +24610,37 @@ this is needed.
             }  /* switch */
             break;
           case ifc_tbs_float:
-            check_assertion(precision == ifc_tps_default);
-            cache_token(cache, tok_float);
+            switch (precision) {
+              case ifc_tps_default:
+                cache_token(cache, tok_float);
+                break;
+              case ifc_tps_bit16:
+                /* These types have no keyword spelling that is correct for
+                   every dialect, so cache the resolved type directly
+                   (mirroring the direct type loader). */
+                cache_resolved_type_token(cache,
+                                          float_type(float16_kind()));
+                break;
+              case ifc_tps_bit32:
+                cache_resolved_type_token(cache,
+                                          float_type(fk_std_float32));
+                break;
+              case ifc_tps_bit64:
+                cache_resolved_type_token(cache,
+                                          float_type(fk_std_float64));
+                break;
+              case ifc_tps_bit128:
+                cache_resolved_type_token(cache,
+                                          float_type(fk_std_float128));
+                break;
+              default:
+                { a_string err_msg("Unexpected ", str_for(precision),
+                                   " for ", str_for(basis));
+
+                  ifc_unexpected(module_of(type), err_msg);
+                }
+                goto invalid;
+            }  /* switch */
             break;
           case ifc_tbs_double:
             if (precision == ifc_tps_long) {

src/ifc_modules_write.c

@@ -2713,21 +2713,35 @@ for the float type.
       set_ifc_basis(&fund_type, ifc_tbs_double);
       set_ifc_precision(&fund_type, ifc_tps_long);
       break;
-    case fk_float128:
+    case fk_std_float128:
       set_ifc_basis(&fund_type, ifc_tbs_float);
       set_ifc_precision(&fund_type, ifc_tps_bit128);
       break;
     case fk_float16:
+    case fk_std_float16:
+      set_ifc_basis(&fund_type, ifc_tbs_float);
+      set_ifc_precision(&fund_type, ifc_tps_bit16);
+      break;
+    case fk_std_float32:
+      set_ifc_basis(&fund_type, ifc_tbs_float);
+      set_ifc_precision(&fund_type, ifc_tps_bit32);
+      break;
+    case fk_std_float64:
+      set_ifc_basis(&fund_type, ifc_tbs_float);
+      set_ifc_precision(&fund_type, ifc_tps_bit64);
+      break;
+    case fk_float128:
     case fk_fp16:
     case fk_float32x:
     case fk_float64x:
     case fk_float80:
     case fk_std_bfloat16:
-    case fk_std_float16:
-    case fk_std_float32:
-    case fk_std_float64:
-    case fk_std_float128:
     case fk_last:
+      /* These extended floating-point kinds have no IFC fundamental-type
+         encoding that distinguishes them from other floating-point types
+         of the same size ("__fp16" and "__float128" in particular have
+         different manglings than "_Float16" and "_Float128"); they will
+         be covered by an EDG extension type. */
       ifc_write_catastrophe();
       break;
     default_is_unexpected();
@@ -6042,6 +6056,13 @@ Add all the types in the given scope to the given IL -> IFC mapping.
          information. */
       continue;
     }  /* if */
+    if (type->kind == tk_typeref && type->variant.typeref.predeclared) {
+      /* Skip predeclared typedefs (e.g., "_Float16", which is entered in gnu
+         and clang emulation modes):  they are re-created by the predefined
+         type entry processing of an importing translation unit, and the
+         types of some of them cannot currently be written to an IFC file. */
+      continue;
+    }  /* if */
     (void)il_map->find_or_enter_type(type);
   }  /* for */
 }  /* dump_scope_types */

src/sys_predef.c

@@ -3091,9 +3091,7 @@ Enter predeclared symbols as required by the implementation.
   if (float16_enabled) {
     (void)enter_predefined_typedef(
                     "_Float16",
-                    ((gnu_version_is(>= 130000) ||
-                      clang_version_is(>= 150000)) ? float_type(fk_std_float16)
-                                                   : float_type(fk_float16)));
+                    float_type(float16_kind()));
   }  /* if */
   if (float80_enabled) {
     (void)enter_predefined_typedef(

src/types.h

@@ -54,6 +54,19 @@ this routine should not be used when checking type qualifiers.
 }  /* skip_typerefs */
 
 
+INLINE a_float_kind float16_kind(void)
+/*
+Return the floating-point kind used for the type name "_Float16" in the
+current mode:  GNU versions 13 and later and Clang versions 15 and later
+use the standard "_Float16" type, and other modes use the GNU extension
+type.
+*/
+{
+  return (gnu_version_is(>= 130000) || clang_version_is(>= 150000)) ?
+             fk_std_float16 : fk_float16;
+}  /* float16_kind */
+
+
 INLINE a_boolean is_lexical_typeref(a_type_ptr tp)
 /*
 Return TRUE if tp is a trk_template_arg_list or trk_name_qualifier typeref,

tests/tests/modules/eifc/modules/export-float16-gnu/.test.rto/default.1.1.txt

@@ -0,0 +1 @@
+cpfe -DTEST_NUMBER=1 --module_import_diagnostics -d-module_report --c++20 --gnu_version=150100 --modules --module_interface foo.ixx

tests/tests/modules/eifc/modules/export-float16-gnu/.test.rto/default.1.2.txt

@@ -0,0 +1,2 @@
+cpfe -DTEST_NUMBER=1 --module_import_diagnostics -d-module_report --c++20 --gnu_version=150100 --modules Test_name.c
+2 modules declarations processed (0 failed).

tests/tests/modules/eifc/modules/export-float16-gnu/.test.rto/edg_x86_32_cp.1.2.txt

@@ -0,0 +1,3 @@
+cpfe -DTEST_NUMBER=1 --module_import_diagnostics -d-module_report --c++20 --gnu_version=150100 --modules Test_name.c
+2 modules declarations processed (0 failed).
+2 modules declarations processed (0 failed).

tests/tests/modules/eifc/modules/export-float16-gnu/.test.rto/edg_x86_64_cp.1.2.txt

@@ -0,0 +1,3 @@
+cpfe -DTEST_NUMBER=1 --module_import_diagnostics -d-module_report --c++20 --gnu_version=150100 --modules Test_name.c
+2 modules declarations processed (0 failed).
+2 modules declarations processed (0 failed).

tests/tests/modules/eifc/modules/export-float16-gnu/foo.ixx

@@ -0,0 +1,5 @@
+export module foo;
+
+export _Float16 half(_Float16 v) {
+  return v / 2;
+}

tests/tests/modules/eifc/modules/export-float16-gnu/test.mft.cpp

@@ -0,0 +1,10 @@
+//type:cp
+//module_files:foo.ixx
+//options_all:--module_import_diagnostics -d-module_report --c++20 --gnu_version=150100 --modules
+
+import foo;
+
+int main() {
+  _Float16 x = half(8);
+  return 0;
+}