test/f90: fix cross-language attribute tests

It appears the old interpretation of how we store an integer value in
attribute is to store a pointer (address) to an integer. This creates
the ridiculous case when we retrieve a attribute value set in Fortran,
we need *guess* whether the integer attr is set in F77 or F90 and cast
the returned attr from (void *) to either (int *) or (MPI_Aint *).

In an alternate interpretation, we simply store an integer as a scalar.
If we retrieve the integer from C, simply cast the (void *) into an
integer. Integer cast is always safe! Simply, the new interpretation
always treats an attribute as a scalar value (including ptr address).

There is no way to implement the old interpretation with a C MPI ABI.

Note, the new interpretation only affects applications that want to
retrieve an attribute set in Fortran but get in C. I don't think we have
any real applications involving such case.

Author: hzhou

test/mpi/f90/attr/attrlangc.c

@@ -574,74 +574,15 @@ void csetmpiwin_(MPI_Fint * fwin, MPI_Fint * fkey, MPI_Aint * val, MPI_Fint * er
 /* ----------------------------------------------------------------------- */
 void ccompareint2aint_(MPI_Fint * in1, MPI_Aint * in2, MPI_Fint * result)
 {
-    static int idx = -1;
-    if (sizeof(MPI_Fint) == sizeof(MPI_Aint)) {
-        *result = *in1 == *in2;
-    } else if (sizeof(MPI_Fint) < sizeof(MPI_Aint)) {
-        /* Assume Aint no smaller than Fint, and that size of aint
-         * is a multiple of the size of fint) */
-        MPI_Fint *v2 = (MPI_Fint *) in2;
-        if (idx < 0) {
-            MPI_Aint av = 1;
-            MPI_Fint *fa = (MPI_Fint *) & av;
-            if ((sizeof(MPI_Aint) % sizeof(MPI_Fint)) != 0) {
-                fprintf(stderr,
-                        "PANIC: size of MPI_Aint = %d not a multiple of MPI_Fint = %d\n",
-                        (int) sizeof(MPI_Aint), (int) sizeof(MPI_Fint));
-                MPI_Abort(MPI_COMM_WORLD, 1);
-            }
-            for (idx = sizeof(MPI_Aint) / sizeof(MPI_Fint); idx >= 0; idx--)
-                if (fa[idx])
-                    break;
-            if (idx < 0) {
-                fprintf(stderr, "Unable to determine low word of Fint in Aint\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-            }
-            *result = *in1 == v2[idx];
-        }
-    } else {
-        fprintf(stderr, "PANIC: sizeof(MPI_Fint) = %d > sizeof(MPI_Aint) %d\n",
-                (int) sizeof(MPI_Fint), (int) sizeof(MPI_Aint));
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
+    *result = *in1 == *in2;
 }
 
 void ccompareint2void_(MPI_Fint * in1, void *in2, MPI_Fint * result)
 {
-    static int idx = -1;
-    if (sizeof(MPI_Fint) == sizeof(void *)) {
-        *result = *in1 == *(MPI_Fint *) in2;
-    } else if (sizeof(MPI_Fint) < sizeof(void *)) {
-        /* Assume void* no smaller than Fint, and that size of aint
-         * is a multiple of the size of fint) */
-        MPI_Fint *v2 = (MPI_Fint *) in2;
-        if (idx < 0) {
-            void *av = (void *) 1;
-            MPI_Fint *fa = (MPI_Fint *) & av;
-            if ((sizeof(void *) % sizeof(MPI_Fint)) != 0) {
-                fprintf(stderr,
-                        "PANIC: size of void * = %d not a multiple of MPI_Fint = %d\n",
-                        (int) sizeof(void *), (int) sizeof(MPI_Fint));
-                MPI_Abort(MPI_COMM_WORLD, 1);
-            }
-            for (idx = sizeof(void *) / sizeof(MPI_Fint); idx >= 0; idx--)
-                if (fa[idx])
-                    break;
-            if (idx < 0) {
-                fprintf(stderr, "Unable to determine low word of Fint in void*\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-            }
-            *result = *in1 == v2[idx];
-        }
-    } else {
-        fprintf(stderr, "PANIC: sizeof(MPI_Fint) = %d > sizeof(void*) %d\n",
-                (int) sizeof(MPI_Fint), (int) sizeof(void *));
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
+    *result = *in1 == (MPI_Fint) (intptr_t) in2;
 }
 
 void ccompareaint2void_(MPI_Aint * in1, void *in2, MPI_Fint * result)
 {
-    /* Note that an aint must be >= void * by definition */
-    *result = *in1 == *(MPI_Aint *) in2;
+    *result = *in1 == (MPI_Aint) (intptr_t) in2;
 }

test/mpi/f90/attr/fandcattrc.c

@@ -38,7 +38,7 @@ int chkcomm2inc_(int *keyval, const int *expected, int *ierr);
 int chkcomm2inc_(int *keyval, const int *expected, int *ierr)
 {
     int flag;
-    MPI_Aint *val;
+    MPI_Aint val;
 
     /* See Example 16.19 in MPI 2.2, part B.  The use of MPI_Aint *val
      * and the address of val in the get_attr call is correct, as is
@@ -47,7 +47,7 @@ int chkcomm2inc_(int *keyval, const int *expected, int *ierr)
     if (!flag) {
         *ierr = 1;
     } else {
-        if (*val != *expected) {
+        if (val != *expected) {
             /* In some cases, using printf from a c routine linked
              * with a Fortran routine can cause linking difficulties.
              * To avoid problems in running the tests, this print
@@ -65,7 +65,8 @@ int myCommCopyfn(MPI_Comm comm, int keyval, void *extra_state,
 int myCommCopyfn(MPI_Comm comm, int keyval, void *extra_state,
                  void *attr_val_in, void *attr_val_out, int *flag)
 {
-    *(void **) attr_val_out = (char *) attr_val_in + 2;
+    // *(void **) attr_val_out = (char *) attr_val_in + 2;
+    attr_val_out = (void *) (intptr_t) attr_val_in + 2;
     *flag = 1;
     return MPI_SUCCESS;
 }