diff mbox series

[libfortran] Adapt handling of derived types to new dtype

Message ID 65ed9916-5cb9-1377-d188-e95f1a3d1a4c@netcologne.de
State New
Headers show
Series [libfortran] Adapt handling of derived types to new dtype | expand

Commit Message

Thomas Koenig Jan. 29, 2018, 9:51 p.m. UTC 
Hello world,

this patch fixes the library issues left over from Paul's rank-15 patch
by removing the GFC_DTYPE_DERIVED_* macros and (mostly) handling these
cases separately.

The problem was with folding the type and size into a single word. For
all normal data types, this is perfectly fine, because the sizes are
known to fit. For derived types or characters, there could be a problem
if a user specified a very large size.

Regression-tested. OK for trunk?

Regards

	Thomas

2018-01-29  Thomas Koenig  <tkoenig@gcc.gnu.org>

	PR fortran/37577
	* libgfortran.h: Remove GFC_DTYPE_DERIVED_1, GFC_DTYPE_DERIVED_2,
	GFC_DTYPE_DERIVED_4, GFC_DTYPE_DERIVED_8 and GFC_DTYPE_DERIVED_16.
	* m4/cshift1.m4: Remove GFC_DTYPE_DERIVED_1.
	* generated/cshift1_16.c: Regenerated.
	* generated/cshift1_4.c: Regenerated.
	* generated/cshift1_8.c: Regenerated.
	* intrinsics/cshift0.c: Remove GFC_DTYPE_DERIVED_1.
	* intrinsics/pack_generic.c (pack): Move handling of other types
	into separate switch statement.
	* intrinsics/spread_generic.c (spread): Likewise.
	(spread_scalar): Likewise.
	* intrinsics/unpack_generic.c (unpack1): Likewise.
	(unpack0): Likewise.
	* runtime/in_pack_generic.c (internal_pack): Likewise.
	* runtime/in_unpack_generic.c (internal_unpack): Likewise.

Comments

Janne Blomqvist Jan. 30, 2018, 4:28 p.m. UTC | #1 
On Mon, Jan 29, 2018 at 11:51 PM, Thomas Koenig <tkoenig@netcologne.de> wrote:
> Hello world,
>
> this patch fixes the library issues left over from Paul's rank-15 patch
> by removing the GFC_DTYPE_DERIVED_* macros and (mostly) handling these
> cases separately.
>
> The problem was with folding the type and size into a single word. For
> all normal data types, this is perfectly fine, because the sizes are
> known to fit. For derived types or characters, there could be a problem
> if a user specified a very large size.
>
> Regression-tested. OK for trunk?

Ok, thanks.
diff mbox series

Patch

Index: libgfortran.h
===================================================================
--- libgfortran.h	(Revision 257131)
+++ libgfortran.h	(Arbeitskopie)
@@ -490,19 +490,6 @@  typedef gfc_array_i4 gfc_array_s4;
    | (sizeof(GFC_COMPLEX_16) << GFC_DTYPE_SIZE_SHIFT))
 #endif
 
-#define GFC_DTYPE_DERIVED_1 ((BT_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
-   | (sizeof(GFC_INTEGER_1) << GFC_DTYPE_SIZE_SHIFT))
-#define GFC_DTYPE_DERIVED_2 ((BT_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
-   | (sizeof(GFC_INTEGER_2) << GFC_DTYPE_SIZE_SHIFT))
-#define GFC_DTYPE_DERIVED_4 ((BT_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
-   | (sizeof(GFC_INTEGER_4) << GFC_DTYPE_SIZE_SHIFT))
-#define GFC_DTYPE_DERIVED_8 ((BT_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
-   | (sizeof(GFC_INTEGER_8) << GFC_DTYPE_SIZE_SHIFT))
-#ifdef HAVE_GFC_INTEGER_16
-#define GFC_DTYPE_DERIVED_16 ((BT_DERIVED << GFC_DTYPE_TYPE_SHIFT) \
-   | (sizeof(GFC_INTEGER_16) << GFC_DTYPE_SIZE_SHIFT))
-#endif
-
 /* Macros to determine the alignment of pointers.  */
 
 #define GFC_UNALIGNED_2(x) (((uintptr_t)(x)) & \
Index: m4/cshift1.m4
===================================================================
--- m4/cshift1.m4	(Revision 257131)
+++ m4/cshift1.m4	(Arbeitskopie)
@@ -121,7 +121,6 @@  cshift1 (gfc_array_char * const restrict ret,
   {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       cshift1_'atype_kind`_i1 ((gfc_array_i1 *)ret, (gfc_array_i1 *) array,
       			h, pwhich);
       return;
Index: generated/cshift1_16.c
===================================================================
--- generated/cshift1_16.c	(Revision 257131)
+++ generated/cshift1_16.c	(Arbeitskopie)
@@ -120,7 +120,6 @@  cshift1 (gfc_array_char * const restrict ret,
   {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       cshift1_16_i1 ((gfc_array_i1 *)ret, (gfc_array_i1 *) array,
       			h, pwhich);
       return;
Index: generated/cshift1_4.c
===================================================================
--- generated/cshift1_4.c	(Revision 257131)
+++ generated/cshift1_4.c	(Arbeitskopie)
@@ -120,7 +120,6 @@  cshift1 (gfc_array_char * const restrict ret,
   {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       cshift1_4_i1 ((gfc_array_i1 *)ret, (gfc_array_i1 *) array,
       			h, pwhich);
       return;
Index: generated/cshift1_8.c
===================================================================
--- generated/cshift1_8.c	(Revision 257131)
+++ generated/cshift1_8.c	(Arbeitskopie)
@@ -120,7 +120,6 @@  cshift1 (gfc_array_char * const restrict ret,
   {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       cshift1_8_i1 ((gfc_array_i1 *)ret, (gfc_array_i1 *) array,
       			h, pwhich);
       return;
Index: intrinsics/cshift0.c
===================================================================
--- intrinsics/cshift0.c	(Revision 257131)
+++ intrinsics/cshift0.c	(Arbeitskopie)
@@ -95,7 +95,6 @@  cshift0 (gfc_array_char * ret, const gfc_array_cha
     {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       cshift0_i1 ((gfc_array_i1 *)ret, (gfc_array_i1 *) array, shift, which);
       return;
 
Index: intrinsics/pack_generic.c
===================================================================
--- intrinsics/pack_generic.c	(Revision 257131)
+++ intrinsics/pack_generic.c	(Arbeitskopie)
@@ -255,7 +255,6 @@  pack (gfc_array_char *ret, const gfc_array_char *a
     {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       pack_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) array,
 	       (gfc_array_l1 *) mask, (gfc_array_i1 *) vector);
       return;
@@ -349,12 +348,19 @@  pack (gfc_array_char *ret, const gfc_array_char *a
       return;
 # endif
 #endif
+    }
+  
+  /* For other types, let's check the actual alignment of the data pointers.
+     If they are aligned, we can safely call the unpack functions.  */
 
-      /* For derived types, let's check the actual alignment of the
-	 data pointers.  If they are aligned, we can safely call
-	 the unpack functions.  */
+  switch (GFC_DESCRIPTOR_SIZE (array))
+    {
+    case 1:
+      pack_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) array,
+	       (gfc_array_l1 *) mask, (gfc_array_i1 *) vector);
+      return;
 
-    case GFC_DTYPE_DERIVED_2:
+    case 2:
       if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(array->base_addr)
 	  || (vector && GFC_UNALIGNED_2(vector->base_addr)))
 	break;
@@ -364,8 +370,8 @@  pack (gfc_array_char *ret, const gfc_array_char *a
 		   (gfc_array_l1 *) mask, (gfc_array_i2 *) vector);
 	  return;
 	}
-
-    case GFC_DTYPE_DERIVED_4:
+	      
+    case 4:
       if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(array->base_addr)
 	  || (vector && GFC_UNALIGNED_4(vector->base_addr)))
 	break;
@@ -376,7 +382,7 @@  pack (gfc_array_char *ret, const gfc_array_char *a
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_8:
+    case 8:
       if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(array->base_addr)
 	  || (vector && GFC_UNALIGNED_8(vector->base_addr)))
 	break;
@@ -387,8 +393,8 @@  pack (gfc_array_char *ret, const gfc_array_char *a
 	  return;
 	}
 
-#ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_DERIVED_16:
+#ifdef HAVE_GFC_INTEGER_16	      
+    case 16:
       if (GFC_UNALIGNED_16(ret->base_addr) || GFC_UNALIGNED_16(array->base_addr)
 	  || (vector && GFC_UNALIGNED_16(vector->base_addr)))
 	break;
@@ -395,11 +401,12 @@  pack (gfc_array_char *ret, const gfc_array_char *a
       else
 	{
 	  pack_i16 ((gfc_array_i16 *) ret, (gfc_array_i16 *) array,
-		   (gfc_array_l1 *) mask, (gfc_array_i16 *) vector);
+		    (gfc_array_l1 *) mask, (gfc_array_i16 *) vector);
 	  return;
 	}
 #endif
-
+    default:
+      break;
     }
 
   size = GFC_DESCRIPTOR_SIZE (array);
Index: intrinsics/spread_generic.c
===================================================================
--- intrinsics/spread_generic.c	(Revision 257131)
+++ intrinsics/spread_generic.c	(Arbeitskopie)
@@ -274,7 +274,6 @@  spread (gfc_array_char *ret, const gfc_array_char
   type_size = GFC_DTYPE_TYPE_SIZE(ret);
   switch(type_size)
     {
-    case GFC_DTYPE_DERIVED_1:
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
       spread_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) source,
@@ -371,7 +370,16 @@  spread (gfc_array_char *ret, const gfc_array_char
 # endif
 #endif
 
-    case GFC_DTYPE_DERIVED_2:
+    }
+  
+  switch (GFC_DESCRIPTOR_SIZE (ret))
+    {
+    case 1:
+      spread_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) source,
+		 *along, *pncopies);
+      return;
+
+    case 2:
       if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(source->base_addr))
 	break;
       else
@@ -381,7 +389,7 @@  spread (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_4:
+    case 4:
       if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(source->base_addr))
 	break;
       else
@@ -391,7 +399,7 @@  spread (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_8:
+    case 8:
       if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(source->base_addr))
 	break;
       else
@@ -400,9 +408,8 @@  spread (gfc_array_char *ret, const gfc_array_char
 		     *along, *pncopies);
 	  return;
 	}
-
 #ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_DERIVED_16:
+    case 16:
       if (GFC_UNALIGNED_16(ret->base_addr)
 	  || GFC_UNALIGNED_16(source->base_addr))
 	break;
@@ -411,8 +418,9 @@  spread (gfc_array_char *ret, const gfc_array_char
 	  spread_i16 ((gfc_array_i16 *) ret, (gfc_array_i16 *) source,
 		      *along, *pncopies);
 	  return;
-	}
+	    }
 #endif
+
     }
 
   spread_internal (ret, source, along, pncopies);
@@ -470,7 +478,6 @@  spread_scalar (gfc_array_char *ret, const char *so
   type_size = GFC_DTYPE_TYPE_SIZE(ret);
   switch(type_size)
     {
-    case GFC_DTYPE_DERIVED_1:
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
       spread_scalar_i1 ((gfc_array_i1 *) ret, (GFC_INTEGER_1 *) source,
@@ -567,7 +574,16 @@  spread_scalar (gfc_array_char *ret, const char *so
 # endif
 #endif
 
-    case GFC_DTYPE_DERIVED_2:
+    }
+
+  switch (GFC_DESCRIPTOR_SIZE(ret))
+    {
+    case 1:
+      spread_scalar_i1 ((gfc_array_i1 *) ret, (GFC_INTEGER_1 *) source,
+			*along, *pncopies);
+      return;
+
+    case 2:
       if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(source))
 	break;
       else
@@ -577,7 +593,7 @@  spread_scalar (gfc_array_char *ret, const char *so
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_4:
+    case 4:
       if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(source))
 	break;
       else
@@ -587,7 +603,7 @@  spread_scalar (gfc_array_char *ret, const char *so
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_8:
+    case 8:
       if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(source))
 	break;
       else
@@ -597,7 +613,7 @@  spread_scalar (gfc_array_char *ret, const char *so
 	  return;
 	}
 #ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_DERIVED_16:
+    case 16:
       if (GFC_UNALIGNED_16(ret->base_addr) || GFC_UNALIGNED_16(source))
 	break;
       else
@@ -607,6 +623,8 @@  spread_scalar (gfc_array_char *ret, const char *so
 	  return;
 	}
 #endif
+    default:
+      break;
     }
 
   spread_internal_scalar (ret, source, along, pncopies);
Index: intrinsics/unpack_generic.c
===================================================================
--- intrinsics/unpack_generic.c	(Revision 257131)
+++ intrinsics/unpack_generic.c	(Arbeitskopie)
@@ -222,7 +222,6 @@  unpack1 (gfc_array_char *ret, const gfc_array_char
     {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       unpack1_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
 		  mask, (gfc_array_i1 *) field);
       return;
@@ -317,7 +316,16 @@  unpack1 (gfc_array_char *ret, const gfc_array_char
 # endif
 #endif
 
-    case GFC_DTYPE_DERIVED_2:
+    }
+
+  switch (GFC_DESCRIPTOR_SIZE(ret))
+    {
+    case 1:
+      unpack1_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
+		  mask, (gfc_array_i1 *) field);
+      return;
+
+    case 2:
       if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(vector->base_addr)
 	  || GFC_UNALIGNED_2(field->base_addr))
 	break;
@@ -328,7 +336,7 @@  unpack1 (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_4:
+    case 4:
       if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(vector->base_addr)
 	  || GFC_UNALIGNED_4(field->base_addr))
 	break;
@@ -339,7 +347,7 @@  unpack1 (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_8:
+    case 8:
       if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(vector->base_addr)
 	  || GFC_UNALIGNED_8(field->base_addr))
 	break;
@@ -351,7 +359,7 @@  unpack1 (gfc_array_char *ret, const gfc_array_char
 	}
 
 #ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_DERIVED_16:
+    case 16:
       if (GFC_UNALIGNED_16(ret->base_addr)
 	  || GFC_UNALIGNED_16(vector->base_addr)
 	  || GFC_UNALIGNED_16(field->base_addr))
@@ -363,6 +371,8 @@  unpack1 (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 #endif
+    default:
+      break;
     }
 
   unpack_internal (ret, vector, mask, field, size);
@@ -433,7 +443,6 @@  unpack0 (gfc_array_char *ret, const gfc_array_char
     {
     case GFC_DTYPE_LOGICAL_1:
     case GFC_DTYPE_INTEGER_1:
-    case GFC_DTYPE_DERIVED_1:
       unpack0_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
 		  mask, (GFC_INTEGER_1 *) field);
       return;
@@ -528,7 +537,16 @@  unpack0 (gfc_array_char *ret, const gfc_array_char
 # endif
 #endif
 
-    case GFC_DTYPE_DERIVED_2:
+    }
+
+  switch (GFC_DESCRIPTOR_SIZE(ret))
+    {
+    case 1:
+      unpack0_i1 ((gfc_array_i1 *) ret, (gfc_array_i1 *) vector,
+		  mask, (GFC_INTEGER_1 *) field);
+      return;
+
+    case 2:
       if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(vector->base_addr)
 	  || GFC_UNALIGNED_2(field))
 	break;
@@ -539,7 +557,7 @@  unpack0 (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_4:
+    case 4:
       if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(vector->base_addr)
 	  || GFC_UNALIGNED_4(field))
 	break;
@@ -550,7 +568,7 @@  unpack0 (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_8:
+    case 8:
       if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(vector->base_addr)
 	  || GFC_UNALIGNED_8(field))
 	break;
@@ -562,7 +580,7 @@  unpack0 (gfc_array_char *ret, const gfc_array_char
 	}
 
 #ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_DERIVED_16:
+    case 16:
       if (GFC_UNALIGNED_16(ret->base_addr)
 	  || GFC_UNALIGNED_16(vector->base_addr)
 	  || GFC_UNALIGNED_16(field))
@@ -574,7 +592,6 @@  unpack0 (gfc_array_char *ret, const gfc_array_char
 	  return;
 	}
 #endif
-
     }
 
   memset (&tmp, 0, sizeof (tmp));
Index: runtime/in_pack_generic.c
===================================================================
--- runtime/in_pack_generic.c	(Revision 257131)
+++ runtime/in_pack_generic.c	(Arbeitskopie)
@@ -55,7 +55,6 @@  internal_pack (gfc_array_char * source)
     {
     case GFC_DTYPE_INTEGER_1:
     case GFC_DTYPE_LOGICAL_1:
-    case GFC_DTYPE_DERIVED_1:
       return internal_pack_1 ((gfc_array_i1 *) source);
 
     case GFC_DTYPE_INTEGER_2:
@@ -123,19 +122,28 @@  internal_pack (gfc_array_char * source)
 # endif
 #endif
 
-    case GFC_DTYPE_DERIVED_2:
+    default:
+      break;
+    }
+
+  switch(GFC_DESCRIPTOR_SIZE (source))
+    {
+    case 1:
+      return internal_pack_1 ((gfc_array_i1 *) source);
+
+    case 2:
       if (GFC_UNALIGNED_2(source->base_addr))
 	break;
       else
 	return internal_pack_2 ((gfc_array_i2 *) source);
 
-    case GFC_DTYPE_DERIVED_4:
+    case 4:
       if (GFC_UNALIGNED_4(source->base_addr))
 	break;
       else
 	return internal_pack_4 ((gfc_array_i4 *) source);
 
-    case GFC_DTYPE_DERIVED_8:
+    case 8:
       if (GFC_UNALIGNED_8(source->base_addr))
 	break;
       else
@@ -142,17 +150,16 @@  internal_pack (gfc_array_char * source)
 	return internal_pack_8 ((gfc_array_i8 *) source);
 
 #ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_DERIVED_16:
+    case 16:
       if (GFC_UNALIGNED_16(source->base_addr))
 	break;
       else
 	return internal_pack_16 ((gfc_array_i16 *) source);
 #endif
-
     default:
       break;
     }
-
+  
   dim = GFC_DESCRIPTOR_RANK (source);
   ssize = 1;
   packed = 1;
Index: runtime/in_unpack_generic.c
===================================================================
--- runtime/in_unpack_generic.c	(Revision 257131)
+++ runtime/in_unpack_generic.c	(Arbeitskopie)
@@ -54,7 +54,6 @@  internal_unpack (gfc_array_char * d, const void *
     {
     case GFC_DTYPE_INTEGER_1:
     case GFC_DTYPE_LOGICAL_1:
-    case GFC_DTYPE_DERIVED_1:
       internal_unpack_1 ((gfc_array_i1 *) d, (const GFC_INTEGER_1 *) s);
       return;
 
@@ -136,7 +135,17 @@  internal_unpack (gfc_array_char * d, const void *
 # endif
 #endif
 
-    case GFC_DTYPE_DERIVED_2:
+    default:
+      break;
+    }
+
+  switch (GFC_DESCRIPTOR_SIZE(d))
+    {
+    case 1:
+      internal_unpack_1 ((gfc_array_i1 *) d, (const GFC_INTEGER_1 *) s);
+      return;
+
+    case 2:
       if (GFC_UNALIGNED_2(d->base_addr) || GFC_UNALIGNED_2(s))
 	break;
       else
@@ -144,7 +153,8 @@  internal_unpack (gfc_array_char * d, const void *
 	  internal_unpack_2 ((gfc_array_i2 *) d, (const GFC_INTEGER_2 *) s);
 	  return;
 	}
-    case GFC_DTYPE_DERIVED_4:
+      
+    case 4:
       if (GFC_UNALIGNED_4(d->base_addr) || GFC_UNALIGNED_4(s))
 	break;
       else
@@ -153,7 +163,7 @@  internal_unpack (gfc_array_char * d, const void *
 	  return;
 	}
 
-    case GFC_DTYPE_DERIVED_8:
+    case 8:
       if (GFC_UNALIGNED_8(d->base_addr) || GFC_UNALIGNED_8(s))
 	break;
       else
@@ -163,7 +173,7 @@  internal_unpack (gfc_array_char * d, const void *
 	}
 
 #ifdef HAVE_GFC_INTEGER_16
-    case GFC_DTYPE_DERIVED_16:
+    case 16:
       if (GFC_UNALIGNED_16(d->base_addr) || GFC_UNALIGNED_16(s))
 	break;
       else
@@ -172,7 +182,6 @@  internal_unpack (gfc_array_char * d, const void *
 	  return;
 	}
 #endif
-
     default:
       break;
     }