[svn-r9329]

Purpose:
Feature

Description:
Datatypes and groups now use H5FO "file object" code that was previously
only used by datasets.  These objects will hold a file open if the file
is closed but they have not yet been closed.  If these objects are unlinked
then relinked, they will not be destroyed.  If they are opened twice (even
by two different names), both IDs will "see" changes made to the object
using the other ID.
When an object is opened using two different names (e.g., if a dataset was
opened under one name, then mounted and opened under its new name), calling
H5Iget_name() on a given hid_t will return the name used to open that hid_t,
not the current name of the object (this is a feature, and a change from the
previous behavior of datasets).

Solution:
Used H5FO code that was already in place for datasets.  Broke H5D_t's, H5T_t's,
and H5G_t's into a "shared" struct and a private struct.  The shared structs
(H5D_shared_t, etc.) hold the object's information and are used by all IDs
that point to a given object in the file.  The private structs are pointed
to by the hid_t and contain the object's group entry information (including its
name) and a pointer to the shared struct for that object.
This changed the naming of structs throughout the library (e.g., datatype->size
is now datatype->shared->size).  I added an updated H5Tinit.c to windows.zip.

Platforms tested:
Visual Studio 7, sleipnir, arabica, verbena

Misc. update:

1 files changed, 286 insertions, 250 deletions

diff --git a/src/H5Odtype.c b/src/H5Odtype.c
index 3c44b26..807aaf3 100644
--- a/src/H5Odtype.c
+++ b/src/H5Odtype.c
@@ -68,6 +68,7 @@ const H5O_class_t H5O_DTYPE[1] = {{
 
 /* Declare external the free list for H5T_t's */
 H5FL_EXTERN(H5T_t);
+H5FL_EXTERN(H5T_shared_t);
 
 
 /*-------------------------------------------------------------------------
@@ -97,39 +98,39 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
 
     /* check args */
     assert(pp && *pp);
-    assert(dt);
+    assert(dt && dt->shared);
 
     /* decode */
     UINT32DECODE(*pp, flags);
     version = (flags>>4) & 0x0f;
     if (version!=H5O_DTYPE_VERSION_COMPAT && version!=H5O_DTYPE_VERSION_UPDATED)
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTLOAD, FAIL, "bad version number for data type message");
-    dt->type = (H5T_class_t)(flags & 0x0f);
+    dt->shared->type = (H5T_class_t)(flags & 0x0f);
     flags >>= 8;
-    UINT32DECODE(*pp, dt->size);
+    UINT32DECODE(*pp, dt->shared->size);
 
-    switch (dt->type) {
+    switch (dt->shared->type) {
         case H5T_INTEGER:
             /*
              * Integer types...
              */
-            dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
-            dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-            dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-            dt->u.atomic.u.i.sign = (flags & 0x8) ? H5T_SGN_2 : H5T_SGN_NONE;
-            UINT16DECODE(*pp, dt->u.atomic.offset);
-            UINT16DECODE(*pp, dt->u.atomic.prec);
+            dt->shared->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+            dt->shared->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->shared->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->shared->u.atomic.u.i.sign = (flags & 0x8) ? H5T_SGN_2 : H5T_SGN_NONE;
+            UINT16DECODE(*pp, dt->shared->u.atomic.offset);
+            UINT16DECODE(*pp, dt->shared->u.atomic.prec);
             break;
 
         case H5T_BITFIELD:
             /*
              * Bit fields...
              */
-            dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
-            dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-            dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-            UINT16DECODE(*pp, dt->u.atomic.offset);
-            UINT16DECODE(*pp, dt->u.atomic.prec);
+            dt->shared->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+            dt->shared->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->shared->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            UINT16DECODE(*pp, dt->shared->u.atomic.offset);
+            UINT16DECODE(*pp, dt->shared->u.atomic.prec);
             break;
 
         case H5T_OPAQUE:
@@ -138,10 +139,10 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
              */
             z = flags & 0xff;
             assert(0==(z&0x7)); /*must be aligned*/
-            if (NULL==(dt->u.opaque.tag=H5MM_malloc(z+1)))
+            if (NULL==(dt->shared->u.opaque.tag=H5MM_malloc(z+1)))
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
-            HDmemcpy(dt->u.opaque.tag, *pp, z);
-            dt->u.opaque.tag[z] = '\0';
+            HDmemcpy(dt->shared->u.opaque.tag, *pp, z);
+            dt->shared->u.opaque.tag[z] = '\0';
             *pp += z;
             break;
 
@@ -149,48 +150,48 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
             /*
              * Floating-point types...
              */
-            dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
-            dt->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-            dt->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
-            dt->u.atomic.u.f.pad = (flags & 0x8) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->shared->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+            dt->shared->u.atomic.lsb_pad = (flags & 0x2) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->shared->u.atomic.msb_pad = (flags & 0x4) ? H5T_PAD_ONE : H5T_PAD_ZERO;
+            dt->shared->u.atomic.u.f.pad = (flags & 0x8) ? H5T_PAD_ONE : H5T_PAD_ZERO;
             switch ((flags >> 4) & 0x03) {
                 case 0:
-                    dt->u.atomic.u.f.norm = H5T_NORM_NONE;
+                    dt->shared->u.atomic.u.f.norm = H5T_NORM_NONE;
                     break;
                 case 1:
-                    dt->u.atomic.u.f.norm = H5T_NORM_MSBSET;
+                    dt->shared->u.atomic.u.f.norm = H5T_NORM_MSBSET;
                     break;
                 case 2:
-                    dt->u.atomic.u.f.norm = H5T_NORM_IMPLIED;
+                    dt->shared->u.atomic.u.f.norm = H5T_NORM_IMPLIED;
                     break;
                 default:
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown floating-point normalization");
             }
-            dt->u.atomic.u.f.sign = (flags >> 8) & 0xff;
-            UINT16DECODE(*pp, dt->u.atomic.offset);
-            UINT16DECODE(*pp, dt->u.atomic.prec);
-            dt->u.atomic.u.f.epos = *(*pp)++;
-            dt->u.atomic.u.f.esize = *(*pp)++;
-            assert(dt->u.atomic.u.f.esize > 0);
-            dt->u.atomic.u.f.mpos = *(*pp)++;
-            dt->u.atomic.u.f.msize = *(*pp)++;
-            assert(dt->u.atomic.u.f.msize > 0);
-            UINT32DECODE(*pp, dt->u.atomic.u.f.ebias);
+            dt->shared->u.atomic.u.f.sign = (flags >> 8) & 0xff;
+            UINT16DECODE(*pp, dt->shared->u.atomic.offset);
+            UINT16DECODE(*pp, dt->shared->u.atomic.prec);
+            dt->shared->u.atomic.u.f.epos = *(*pp)++;
+            dt->shared->u.atomic.u.f.esize = *(*pp)++;
+            assert(dt->shared->u.atomic.u.f.esize > 0);
+            dt->shared->u.atomic.u.f.mpos = *(*pp)++;
+            dt->shared->u.atomic.u.f.msize = *(*pp)++;
+            assert(dt->shared->u.atomic.u.f.msize > 0);
+            UINT32DECODE(*pp, dt->shared->u.atomic.u.f.ebias);
             break;
 
         case H5T_COMPOUND:
             /*
              * Compound data types...
              */
-            dt->u.compnd.nmembs = flags & 0xffff;
-            assert(dt->u.compnd.nmembs > 0);
-            dt->u.compnd.packed = TRUE; /* Start off packed */
-            dt->u.compnd.nalloc = dt->u.compnd.nmembs;
-            dt->u.compnd.memb = H5MM_calloc(dt->u.compnd.nalloc*
+            dt->shared->u.compnd.nmembs = flags & 0xffff;
+            assert(dt->shared->u.compnd.nmembs > 0);
+            dt->shared->u.compnd.packed = TRUE; /* Start off packed */
+            dt->shared->u.compnd.nalloc = dt->shared->u.compnd.nmembs;
+            dt->shared->u.compnd.memb = H5MM_calloc(dt->shared->u.compnd.nalloc*
                             sizeof(H5T_cmemb_t));
-            if (NULL==dt->u.compnd.memb)
+            if (NULL==dt->shared->u.compnd.memb)
                 HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
-            for (i = 0; i < dt->u.compnd.nmembs; i++) {
+            for (i = 0; i < dt->shared->u.compnd.nmembs; i++) {
                 unsigned ndims=0;     /* Number of dimensions of the array field */
                 hsize_t dim[H5O_LAYOUT_NDIMS];  /* Dimensions of the array */
                 int perm[H5O_LAYOUT_NDIMS];     /* Dimension permutations */
@@ -199,12 +200,12 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
                 H5T_t *temp_type;   /* Temporary pointer to the field's datatype */
 
                 /* Decode the field name */
-                dt->u.compnd.memb[i].name = H5MM_xstrdup((const char *)*pp);
+                dt->shared->u.compnd.memb[i].name = H5MM_xstrdup((const char *)*pp);
                 /*multiple of 8 w/ null terminator */
                 *pp += ((HDstrlen((const char *)*pp) + 8) / 8) * 8;
 
                 /* Decode the field offset */
-                UINT32DECODE(*pp, dt->u.compnd.memb[i].offset);
+                UINT32DECODE(*pp, dt->shared->u.compnd.memb[i].offset);
 
                 /* Older versions of the library allowed a field to have
                  * intrinsic 'arrayness'.  Newer versions of the library 
@@ -227,16 +228,19 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
                 } /* end if */
 
                 /* Allocate space for the field's datatype */
-                temp_type = H5FL_CALLOC (H5T_t);
-                if (NULL==temp_type)
+                if(NULL== (temp_type = H5FL_CALLOC (H5T_t)))
+                    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+                if(NULL== (temp_type->shared = H5FL_CALLOC (H5T_shared_t))) {
+                    H5FL_FREE(H5T_t, temp_type);
                     HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+                }
                 temp_type->ent.header = HADDR_UNDEF;
 
                 /* Decode the field's datatype information */
                 if (H5O_dtype_decode_helper(f, pp, temp_type)<0) {
                     for (j=0; j<=i; j++)
-                        H5MM_xfree(dt->u.compnd.memb[j].name);
-                    H5MM_xfree(dt->u.compnd.memb);
+                        H5MM_xfree(dt->shared->u.compnd.memb[j].name);
+                    H5MM_xfree(dt->shared->u.compnd.memb);
                     HGOTO_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "unable to decode member type");
                 }
 
@@ -251,8 +255,8 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
                         /* Create the array datatype for the field */
                         if ((array_dt=H5T_array_create(temp_type,(int)ndims,dim,perm))==NULL) {
                             for (j=0; j<=i; j++)
-                                H5MM_xfree(dt->u.compnd.memb[j].name);
-                            H5MM_xfree(dt->u.compnd.memb);
+                                H5MM_xfree(dt->shared->u.compnd.memb[j].name);
+                            H5MM_xfree(dt->shared->u.compnd.memb);
                             HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to create array datatype");
                         }
 
@@ -268,36 +272,36 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
                  * Set the "force conversion" flag if VL datatype fields exist in this
                  * type or any component types
                  */
-                if(temp_type->force_conv==TRUE)
-                    dt->force_conv=TRUE;
+                if(temp_type->shared->force_conv==TRUE)
+                    dt->shared->force_conv=TRUE;
 
                 /* Member size */
-                dt->u.compnd.memb[i].size = temp_type->size;
+                dt->shared->u.compnd.memb[i].size = temp_type->shared->size;
 
                 /* Set the field datatype (finally :-) */
-                dt->u.compnd.memb[i].type=temp_type;
+                dt->shared->u.compnd.memb[i].type=temp_type;
 
                 /* Check if the datatype stayed packed */
-                if(dt->u.compnd.packed) {
+                if(dt->shared->u.compnd.packed) {
                     /* Check if the member type is packed */
                     if(H5T_is_packed(temp_type)>0) {
                         if(i==0) {
                             /* If the is the first member, the datatype is not packed
                              * if the first member isn't at offset 0
                              */
-                            if(dt->u.compnd.memb[i].offset>0)
-                                dt->u.compnd.packed=FALSE;
+                            if(dt->shared->u.compnd.memb[i].offset>0)
+                                dt->shared->u.compnd.packed=FALSE;
                         } /* end if */
                         else {
                             /* If the is not the first member, the datatype is not
                              * packed if the new member isn't adjoining the previous member
                              */
-                            if(dt->u.compnd.memb[i].offset!=(dt->u.compnd.memb[i-1].offset+dt->u.compnd.memb[i-1].size))
-                                dt->u.compnd.packed=FALSE;
+                            if(dt->shared->u.compnd.memb[i].offset!=(dt->shared->u.compnd.memb[i-1].offset+dt->shared->u.compnd.memb[i-1].size))
+                                dt->shared->u.compnd.packed=FALSE;
                         } /* end else */
                     } /* end if */
                     else
-                        dt->u.compnd.packed=FALSE;
+                        dt->shared->u.compnd.packed=FALSE;
                 } /* end if */
             }
             break;
@@ -306,46 +310,50 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
             /*
              * Enumeration data types...
              */
-            dt->u.enumer.nmembs = dt->u.enumer.nalloc = flags & 0xffff;
-            if (NULL==(dt->parent=H5FL_CALLOC(H5T_t)))
+            dt->shared->u.enumer.nmembs = dt->shared->u.enumer.nalloc = flags & 0xffff;
+            if (NULL==(dt->shared->parent=H5FL_CALLOC(H5T_t)))
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
-            dt->parent->ent.header = HADDR_UNDEF;
-            if (H5O_dtype_decode_helper(f, pp, dt->parent)<0)
+            if(NULL== (dt->shared->parent->shared= H5FL_CALLOC (H5T_shared_t))) {
+                H5FL_FREE(H5T_t, dt->shared->parent);
+                HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+            }
+            dt->shared->parent->ent.header = HADDR_UNDEF;
+            if (H5O_dtype_decode_helper(f, pp, dt->shared->parent)<0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "unable to decode parent data type");
-            if (NULL==(dt->u.enumer.name=H5MM_calloc(dt->u.enumer.nalloc * sizeof(char*))) ||
-                    NULL==(dt->u.enumer.value=H5MM_calloc(dt->u.enumer.nalloc *
-                    dt->parent->size)))
+            if (NULL==(dt->shared->u.enumer.name=H5MM_calloc(dt->shared->u.enumer.nalloc * sizeof(char*))) ||
+                    NULL==(dt->shared->u.enumer.value=H5MM_calloc(dt->shared->u.enumer.nalloc *
+                    dt->shared->parent->shared->size)))
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
 
             /* Names, each a multiple of 8 with null termination */
-            for (i=0; i<dt->u.enumer.nmembs; i++) {
-                dt->u.enumer.name[i] = H5MM_xstrdup((const char*)*pp);
+            for (i=0; i<dt->shared->u.enumer.nmembs; i++) {
+                dt->shared->u.enumer.name[i] = H5MM_xstrdup((const char*)*pp);
                 *pp += ((HDstrlen((const char*)*pp)+8)/8)*8;
             }
 
             /* Values */
-            HDmemcpy(dt->u.enumer.value, *pp,
-                 dt->u.enumer.nmembs * dt->parent->size);
-            *pp += dt->u.enumer.nmembs * dt->parent->size;
+            HDmemcpy(dt->shared->u.enumer.value, *pp,
+                 dt->shared->u.enumer.nmembs * dt->shared->parent->shared->size);
+            *pp += dt->shared->u.enumer.nmembs * dt->shared->parent->shared->size;
             break;
 
         case H5T_REFERENCE: /* Reference data types...  */
-            dt->u.atomic.order = H5T_ORDER_NONE;
-            dt->u.atomic.prec = 8 * dt->size;
-            dt->u.atomic.offset = 0;
-            dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-            dt->u.atomic.msb_pad = H5T_PAD_ZERO;
+            dt->shared->u.atomic.order = H5T_ORDER_NONE;
+            dt->shared->u.atomic.prec = 8 * dt->shared->size;
+            dt->shared->u.atomic.offset = 0;
+            dt->shared->u.atomic.lsb_pad = H5T_PAD_ZERO;
+            dt->shared->u.atomic.msb_pad = H5T_PAD_ZERO;
 
             /* Set reference type */
-            dt->u.atomic.u.r.rtype = (H5R_type_t)(flags & 0x0f);
+            dt->shared->u.atomic.u.r.rtype = (H5R_type_t)(flags & 0x0f);
 
             /* Set extra information for object references, so the hobj_ref_t gets swizzled correctly */
-            if(dt->u.atomic.u.r.rtype==H5R_OBJECT) {
+            if(dt->shared->u.atomic.u.r.rtype==H5R_OBJECT) {
                 /* This type is on disk */
-                dt->u.atomic.u.r.loc = H5T_LOC_DISK;
+                dt->shared->u.atomic.u.r.loc = H5T_LOC_DISK;
 
                 /* This type needs conversion */
-                dt->force_conv=TRUE;
+                dt->shared->force_conv=TRUE;
             } /* end if */
             break;
 
@@ -353,75 +361,88 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
             /*
              * Character string types...
              */
-            dt->u.atomic.order = H5T_ORDER_NONE;
-            dt->u.atomic.prec = 8 * dt->size;
-            dt->u.atomic.offset = 0;
-            dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-            dt->u.atomic.msb_pad = H5T_PAD_ZERO;
-
-            dt->u.atomic.u.s.pad = (H5T_str_t)(flags & 0x0f);
-            dt->u.atomic.u.s.cset = (H5T_cset_t)((flags>>4) & 0x0f);
+            dt->shared->u.atomic.order = H5T_ORDER_NONE;
+            dt->shared->u.atomic.prec = 8 * dt->shared->size;
+            dt->shared->u.atomic.offset = 0;
+            dt->shared->u.atomic.lsb_pad = H5T_PAD_ZERO;
+            dt->shared->u.atomic.msb_pad = H5T_PAD_ZERO;
+
+            dt->shared->u.atomic.u.s.pad = (H5T_str_t)(flags & 0x0f);
+            dt->shared->u.atomic.u.s.cset = (H5T_cset_t)((flags>>4) & 0x0f);
             break;
 
         case H5T_VLEN:  /* Variable length datatypes...  */
             /* Set the type of VL information, either sequence or string */
-            dt->u.vlen.type = (H5T_vlen_type_t)(flags & 0x0f);
-            if(dt->u.vlen.type == H5T_VLEN_STRING) {
-                dt->u.vlen.pad  = (H5T_str_t)((flags>>4) & 0x0f);
-                dt->u.vlen.cset = (H5T_cset_t)((flags>>8) & 0x0f);
+            dt->shared->u.vlen.type = (H5T_vlen_type_t)(flags & 0x0f);
+            if(dt->shared->u.vlen.type == H5T_VLEN_STRING) {
+                dt->shared->u.vlen.pad  = (H5T_str_t)((flags>>4) & 0x0f);
+                dt->shared->u.vlen.cset = (H5T_cset_t)((flags>>8) & 0x0f);
             } /* end if */
 
             /* Decode base type of VL information */
-            if (NULL==(dt->parent = H5FL_CALLOC(H5T_t)))
+            if (NULL==(dt->shared->parent = H5FL_CALLOC(H5T_t)))
+                HGOTO_ERROR (H5E_DATATYPE, H5E_NOSPACE, FAIL, "memory allocation failed");
+            if(NULL== (dt->shared->parent->shared = H5FL_CALLOC (H5T_shared_t))) {
+                H5FL_FREE(H5T_t, dt->shared->parent);
+                HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+            }
+            if (NULL==(dt->shared->parent->shared = H5FL_CALLOC(H5T_shared_t)))
+            {
+                H5FL_FREE(H5T_t, dt->shared->parent);
                 HGOTO_ERROR (H5E_DATATYPE, H5E_NOSPACE, FAIL, "memory allocation failed");
-            dt->parent->ent.header = HADDR_UNDEF;
-            if (H5O_dtype_decode_helper(f, pp, dt->parent)<0)
+            }
+            dt->shared->parent->ent.header = HADDR_UNDEF;
+            if (H5O_dtype_decode_helper(f, pp, dt->shared->parent)<0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "unable to decode VL parent type");
 
-            dt->force_conv=TRUE;
+            dt->shared->force_conv=TRUE;
             /* Mark this type as on disk */
             if (H5T_set_loc(dt, f, H5T_LOC_DISK)<0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid datatype location");
             break;
 
         case H5T_TIME:  /* Time datatypes */
-            dt->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
-            UINT16DECODE(*pp, dt->u.atomic.prec);
+            dt->shared->u.atomic.order = (flags & 0x1) ? H5T_ORDER_BE : H5T_ORDER_LE;
+            UINT16DECODE(*pp, dt->shared->u.atomic.prec);
             break;
 
         case H5T_ARRAY:  /* Array datatypes...  */
             /* Decode the number of dimensions */
-            dt->u.array.ndims = *(*pp)++;
+            dt->shared->u.array.ndims = *(*pp)++;
 
             /* Double-check the number of dimensions */
-            assert(dt->u.array.ndims <= H5S_MAX_RANK);
+            assert(dt->shared->u.array.ndims <= H5S_MAX_RANK);
 
             /* Skip reserved bytes */
             *pp += 3;
 
             /* Decode array dimension sizes & compute number of elements */
-            for (j=0, dt->u.array.nelem=1; j<(unsigned)dt->u.array.ndims; j++) {
-                UINT32DECODE(*pp, dt->u.array.dim[j]);
-                dt->u.array.nelem *= dt->u.array.dim[j];
+            for (j=0, dt->shared->u.array.nelem=1; j<(unsigned)dt->shared->u.array.ndims; j++) {
+                UINT32DECODE(*pp, dt->shared->u.array.dim[j]);
+                dt->shared->u.array.nelem *= dt->shared->u.array.dim[j];
             } /* end for */
 
             /* Decode array dimension permutations (even though they are unused currently) */
-            for (j=0; j<(unsigned)dt->u.array.ndims; j++)
-                UINT32DECODE(*pp, dt->u.array.perm[j]);
+            for (j=0; j<(unsigned)dt->shared->u.array.ndims; j++)
+                UINT32DECODE(*pp, dt->shared->u.array.perm[j]);
 
             /* Decode base type of array */
-            if (NULL==(dt->parent = H5FL_CALLOC(H5T_t)))
+            if (NULL==(dt->shared->parent = H5FL_CALLOC(H5T_t)))
                 HGOTO_ERROR (H5E_DATATYPE, H5E_NOSPACE, FAIL, "memory allocation failed");
-            dt->parent->ent.header = HADDR_UNDEF;
-            if (H5O_dtype_decode_helper(f, pp, dt->parent)<0)
+            if(NULL== (dt->shared->parent->shared = H5FL_CALLOC (H5T_shared_t))) {
+                H5FL_FREE(H5T_t, dt->shared->parent);
+                HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
+            }
+            dt->shared->parent->ent.header = HADDR_UNDEF;
+            if (H5O_dtype_decode_helper(f, pp, dt->shared->parent)<0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTDECODE, FAIL, "unable to decode VL parent type");
 
             /*
              * Set the "force conversion" flag if a VL base datatype is used or
              * or if any components of the base datatype are VL types.
              */
-            if(dt->parent->force_conv==TRUE)
-                dt->force_conv=TRUE;
+            if(dt->shared->parent->shared->force_conv==TRUE)
+                dt->shared->force_conv=TRUE;
             break;
 
         default:
@@ -429,6 +450,14 @@ H5O_dtype_decode_helper(H5F_t *f, const uint8_t **pp, H5T_t *dt)
     }
 
 done:
+    if(ret_value <0)
+    {
+        if(dt->shared != NULL)
+            H5FL_FREE(H5T_shared_t, dt->shared);
+        if(dt != NULL)
+            H5FL_FREE(H5T_t, dt);
+    }
+
     FUNC_LEAVE_NOAPI(ret_value);
 }
 
@@ -466,14 +495,14 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
 
     /* skip the type and class bit-field for now */
     *pp += 4;
-    UINT32ENCODE(*pp, dt->size);
+    UINT32ENCODE(*pp, dt->shared->size);
 
-    switch (dt->type) {
+    switch (dt->shared->type) {
         case H5T_INTEGER:
             /*
              * Integer data types...
              */
-            switch (dt->u.atomic.order) {
+            switch (dt->shared->u.atomic.order) {
                 case H5T_ORDER_LE:
                     break;		/*nothing */
                 case H5T_ORDER_BE:
@@ -483,7 +512,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "byte order is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.lsb_pad) {
+            switch (dt->shared->u.atomic.lsb_pad) {
                 case H5T_PAD_ZERO:
                     break;		/*nothing */
                 case H5T_PAD_ONE:
@@ -493,7 +522,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "bit padding is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.msb_pad) {
+            switch (dt->shared->u.atomic.msb_pad) {
                 case H5T_PAD_ZERO:
                     break;		/*nothing */
                 case H5T_PAD_ONE:
@@ -503,7 +532,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "bit padding is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.u.i.sign) {
+            switch (dt->shared->u.atomic.u.i.sign) {
                 case H5T_SGN_NONE:
                     break;		/*nothing */
                 case H5T_SGN_2:
@@ -513,15 +542,15 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "sign scheme is not supported in file format yet");
             }
 
-            UINT16ENCODE(*pp, dt->u.atomic.offset);
-            UINT16ENCODE(*pp, dt->u.atomic.prec);
+            UINT16ENCODE(*pp, dt->shared->u.atomic.offset);
+            UINT16ENCODE(*pp, dt->shared->u.atomic.prec);
             break;
 
         case H5T_BITFIELD:
             /*
              * Bitfield data types...
              */
-            switch (dt->u.atomic.order) {
+            switch (dt->shared->u.atomic.order) {
                 case H5T_ORDER_LE:
                     break;		/*nothing */
                 case H5T_ORDER_BE:
@@ -531,7 +560,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "byte order is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.lsb_pad) {
+            switch (dt->shared->u.atomic.lsb_pad) {
                 case H5T_PAD_ZERO:
                     break;		/*nothing */
                 case H5T_PAD_ONE:
@@ -541,7 +570,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "bit padding is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.msb_pad) {
+            switch (dt->shared->u.atomic.msb_pad) {
                 case H5T_PAD_ZERO:
                     break;		/*nothing */
                 case H5T_PAD_ONE:
@@ -551,8 +580,8 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "bit padding is not supported in file format yet");
             }
 
-            UINT16ENCODE(*pp, dt->u.atomic.offset);
-            UINT16ENCODE(*pp, dt->u.atomic.prec);
+            UINT16ENCODE(*pp, dt->shared->u.atomic.offset);
+            UINT16ENCODE(*pp, dt->shared->u.atomic.prec);
             break;
 
         case H5T_OPAQUE:
@@ -561,10 +590,10 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
              * multiple of eight characters and null padded (not necessarily
              * null terminated).
              */
-            z = HDstrlen(dt->u.opaque.tag);
+            z = HDstrlen(dt->shared->u.opaque.tag);
             aligned = (z+7) & 0xf8;
             flags |= aligned;
-            HDmemcpy(*pp, dt->u.opaque.tag, MIN(z,aligned));
+            HDmemcpy(*pp, dt->shared->u.opaque.tag, MIN(z,aligned));
             for (n=MIN(z,aligned); n<aligned; n++) (*pp)[n] = 0;
             *pp += aligned;
             break;
@@ -573,7 +602,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
             /*
              * Floating-point types...
              */
-            switch (dt->u.atomic.order) {
+            switch (dt->shared->u.atomic.order) {
                 case H5T_ORDER_LE:
                     break;		/*nothing */
                 case H5T_ORDER_BE:
@@ -583,7 +612,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "byte order is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.lsb_pad) {
+            switch (dt->shared->u.atomic.lsb_pad) {
                 case H5T_PAD_ZERO:
                     break;		/*nothing */
                 case H5T_PAD_ONE:
@@ -593,7 +622,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "bit padding is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.msb_pad) {
+            switch (dt->shared->u.atomic.msb_pad) {
                 case H5T_PAD_ZERO:
                     break;		/*nothing */
                 case H5T_PAD_ONE:
@@ -603,7 +632,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "bit padding is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.u.f.pad) {
+            switch (dt->shared->u.atomic.u.f.pad) {
                 case H5T_PAD_ZERO:
                     break;		/*nothing */
                 case H5T_PAD_ONE:
@@ -613,7 +642,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "bit padding is not supported in file format yet");
             }
 
-            switch (dt->u.atomic.u.f.norm) {
+            switch (dt->shared->u.atomic.u.f.norm) {
                 case H5T_NORM_NONE:
                     break;		/*nothing */
                 case H5T_NORM_MSBSET:
@@ -626,18 +655,18 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "normalization scheme is not supported in file format yet");
             }
 
-            flags |= (dt->u.atomic.u.f.sign << 8) & 0xff00;
-            UINT16ENCODE(*pp, dt->u.atomic.offset);
-            UINT16ENCODE(*pp, dt->u.atomic.prec);
-            assert (dt->u.atomic.u.f.epos<=255);
-            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.epos);
-            assert (dt->u.atomic.u.f.esize<=255);
-            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.esize);
-            assert (dt->u.atomic.u.f.mpos<=255);
-            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.mpos);
-            assert (dt->u.atomic.u.f.msize<=255);
-            *(*pp)++ = (uint8_t)(dt->u.atomic.u.f.msize);
-            UINT32ENCODE(*pp, dt->u.atomic.u.f.ebias);
+            flags |= (dt->shared->u.atomic.u.f.sign << 8) & 0xff00;
+            UINT16ENCODE(*pp, dt->shared->u.atomic.offset);
+            UINT16ENCODE(*pp, dt->shared->u.atomic.prec);
+            assert (dt->shared->u.atomic.u.f.epos<=255);
+            *(*pp)++ = (uint8_t)(dt->shared->u.atomic.u.f.epos);
+            assert (dt->shared->u.atomic.u.f.esize<=255);
+            *(*pp)++ = (uint8_t)(dt->shared->u.atomic.u.f.esize);
+            assert (dt->shared->u.atomic.u.f.mpos<=255);
+            *(*pp)++ = (uint8_t)(dt->shared->u.atomic.u.f.mpos);
+            assert (dt->shared->u.atomic.u.f.msize<=255);
+            *(*pp)++ = (uint8_t)(dt->shared->u.atomic.u.f.msize);
+            UINT32ENCODE(*pp, dt->shared->u.atomic.u.f.ebias);
             break;
 
         case H5T_COMPOUND:
@@ -648,18 +677,18 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
             /*
              * Compound data types...
              */
-            flags = dt->u.compnd.nmembs & 0xffff;
-            for (i=0; i<dt->u.compnd.nmembs; i++) {
+            flags = dt->shared->u.compnd.nmembs & 0xffff;
+            for (i=0; i<dt->shared->u.compnd.nmembs; i++) {
 
                 /* Name, multiple of eight bytes */
-                HDstrcpy((char*)(*pp), dt->u.compnd.memb[i].name);
-                n = HDstrlen(dt->u.compnd.memb[i].name);
+                HDstrcpy((char*)(*pp), dt->shared->u.compnd.memb[i].name);
+                n = HDstrlen(dt->shared->u.compnd.memb[i].name);
                 for (z=n+1; z%8; z++)
                     (*pp)[z] = '\0';
                 *pp += z;
 
                 /* Member offset */
-                UINT32ENCODE(*pp, dt->u.compnd.memb[i].offset);
+                UINT32ENCODE(*pp, dt->shared->u.compnd.memb[i].offset);
 
                 /* If we don't have any array fields, write out the old style
                  * member information, for better backward compatibility
@@ -686,7 +715,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                 } /* end if */
 
                 /* Subtype */
-                if (H5O_dtype_encode_helper(pp, dt->u.compnd.memb[i].type)<0)
+                if (H5O_dtype_encode_helper(pp, dt->shared->u.compnd.memb[i].type)<0)
                     HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "unable to encode member type");
             }
             break;
@@ -695,58 +724,58 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
             /*
              * Enumeration data types...
              */
-            flags = dt->u.enumer.nmembs & 0xffff;
+            flags = dt->shared->u.enumer.nmembs & 0xffff;
 
             /* Parent type */
-            if (H5O_dtype_encode_helper(pp, dt->parent)<0)
+            if (H5O_dtype_encode_helper(pp, dt->shared->parent)<0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "unable to encode parent data type");
             
             /* Names, each a multiple of eight bytes */
-            for (i=0; i<dt->u.enumer.nmembs; i++) {
-                HDstrcpy((char*)(*pp), dt->u.enumer.name[i]);
-                n = HDstrlen(dt->u.enumer.name[i]);
+            for (i=0; i<dt->shared->u.enumer.nmembs; i++) {
+                HDstrcpy((char*)(*pp), dt->shared->u.enumer.name[i]);
+                n = HDstrlen(dt->shared->u.enumer.name[i]);
                 for (z=n+1; z%8; z++)
                     (*pp)[z] = '\0';
                 *pp += z;
             }
 
             /* Values */
-            HDmemcpy(*pp, dt->u.enumer.value, dt->u.enumer.nmembs * dt->parent->size);
-            *pp += dt->u.enumer.nmembs * dt->parent->size;
+            HDmemcpy(*pp, dt->shared->u.enumer.value, dt->shared->u.enumer.nmembs * dt->shared->parent->shared->size);
+            *pp += dt->shared->u.enumer.nmembs * dt->shared->parent->shared->size;
             break;
         
         case H5T_REFERENCE:
-            flags |= (dt->u.atomic.u.r.rtype & 0x0f);
+            flags |= (dt->shared->u.atomic.u.r.rtype & 0x0f);
             break;
             
         case H5T_STRING:
             /*
              * Character string types... (not fully implemented)
              */
-            assert (dt->u.atomic.order == H5T_ORDER_NONE);
-            assert (dt->u.atomic.prec == 8 * dt->size);
-            assert (dt->u.atomic.offset == 0);
-            assert (dt->u.atomic.lsb_pad == H5T_PAD_ZERO);
-            assert (dt->u.atomic.msb_pad == H5T_PAD_ZERO);
-
-            flags |= (dt->u.atomic.u.s.pad & 0x0f);
-            flags |= (dt->u.atomic.u.s.cset & 0x0f) << 4;
+            assert (dt->shared->u.atomic.order == H5T_ORDER_NONE);
+            assert (dt->shared->u.atomic.prec == 8 * dt->shared->size);
+            assert (dt->shared->u.atomic.offset == 0);
+            assert (dt->shared->u.atomic.lsb_pad == H5T_PAD_ZERO);
+            assert (dt->shared->u.atomic.msb_pad == H5T_PAD_ZERO);
+
+            flags |= (dt->shared->u.atomic.u.s.pad & 0x0f);
+            flags |= (dt->shared->u.atomic.u.s.cset & 0x0f) << 4;
             break;
 
         case H5T_VLEN:  /* Variable length datatypes...  */
-            flags |= (dt->u.vlen.type & 0x0f);
-            if(dt->u.vlen.type == H5T_VLEN_STRING) {
-                flags |= (dt->u.vlen.pad   & 0x0f) << 4;
-                flags |= (dt->u.vlen.cset  & 0x0f) << 8;
+            flags |= (dt->shared->u.vlen.type & 0x0f);
+            if(dt->shared->u.vlen.type == H5T_VLEN_STRING) {
+                flags |= (dt->shared->u.vlen.pad   & 0x0f) << 4;
+                flags |= (dt->shared->u.vlen.cset  & 0x0f) << 8;
             } /* end if */
 
             /* Encode base type of VL information */
-            if (H5O_dtype_encode_helper(pp, dt->parent)<0)
+            if (H5O_dtype_encode_helper(pp, dt->shared->parent)<0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "unable to encode VL parent type");
             break;
 
         case H5T_TIME:  /* Time datatypes...  */
-            switch (dt->u.atomic.order) {
+            switch (dt->shared->u.atomic.order) {
                 case H5T_ORDER_LE:
                     break;		/*nothing */
                 case H5T_ORDER_BE:
@@ -755,15 +784,15 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
                 default:
                     HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "byte order is not supported in file format yet");
             }
-            UINT16ENCODE(*pp, dt->u.atomic.prec);
+            UINT16ENCODE(*pp, dt->shared->u.atomic.prec);
             break;
 
         case H5T_ARRAY:  /* Array datatypes...  */
             /* Double-check the number of dimensions */
-            assert(dt->u.array.ndims <= H5S_MAX_RANK);
+            assert(dt->shared->u.array.ndims <= H5S_MAX_RANK);
 
             /* Encode the number of dimensions */
-            *(*pp)++ = dt->u.array.ndims;
+            *(*pp)++ = dt->shared->u.array.ndims;
 
             /* Reserved */
             *(*pp)++ = '\0';
@@ -771,15 +800,15 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
             *(*pp)++ = '\0';
 
             /* Encode array dimensions */
-            for (j=0; j<(unsigned)dt->u.array.ndims; j++)
-                UINT32ENCODE(*pp, dt->u.array.dim[j]);
+            for (j=0; j<(unsigned)dt->shared->u.array.ndims; j++)
+                UINT32ENCODE(*pp, dt->shared->u.array.dim[j]);
 
             /* Encode array dimension permutations */
-            for (j=0; j<(unsigned)dt->u.array.ndims; j++)
-                UINT32ENCODE(*pp, dt->u.array.perm[j]);
+            for (j=0; j<(unsigned)dt->shared->u.array.ndims; j++)
+                UINT32ENCODE(*pp, dt->shared->u.array.perm[j]);
 
             /* Encode base type of array's information */
-            if (H5O_dtype_encode_helper(pp, dt->parent)<0)
+            if (H5O_dtype_encode_helper(pp, dt->shared->parent)<0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "unable to encode VL parent type");
             break;
 
@@ -789,7 +818,7 @@ H5O_dtype_encode_helper(uint8_t **pp, const H5T_t *dt)
     }
 
     /* Encode the type's class, version and bit field */
-    *hdr++ = ((unsigned)(dt->type) & 0x0f) | (((dt->type==H5T_COMPOUND && has_array) ? H5O_DTYPE_VERSION_UPDATED : H5O_DTYPE_VERSION_COMPAT )<<4);
+    *hdr++ = ((unsigned)(dt->shared->type) & 0x0f) | (((dt->shared->type==H5T_COMPOUND && has_array) ? H5O_DTYPE_VERSION_UPDATED : H5O_DTYPE_VERSION_COMPAT )<<4);
     *hdr++ = (flags >> 0) & 0xff;
     *hdr++ = (flags >> 8) & 0xff;
     *hdr++ = (flags >> 16) & 0xff;
@@ -831,7 +860,11 @@ H5O_dtype_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p,
 
     if (NULL==(dt = H5FL_CALLOC(H5T_t)))
         HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
+    if (NULL==(dt->shared=H5FL_CALLOC(H5T_shared_t)))
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
     dt->ent.header = HADDR_UNDEF;
+    dt->shared->fo_count=1;
+
 
     if (H5O_dtype_decode_helper(f, &p, dt) < 0)
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTDECODE, NULL, "can't decode type");
@@ -841,6 +874,8 @@ H5O_dtype_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p,
 
 done:
     if(ret_value==NULL) {
+        if(dt->shared!=NULL)
+            H5FL_FREE(H5T_shared_t, dt->shared);
         if(dt!=NULL)
             H5FL_FREE(H5T_t,dt);
     } /* end if */
@@ -967,7 +1002,7 @@ H5O_dtype_size(H5F_t *f, const void *mesg)
     assert(mesg);
 
     /* Add in the property field length for each datatype class */
-    switch (dt->type) {
+    switch (dt->shared->type) {
         case H5T_INTEGER:
             ret_value += 4;
             break;
@@ -977,7 +1012,7 @@ H5O_dtype_size(H5F_t *f, const void *mesg)
             break;
 
         case H5T_OPAQUE:
-            ret_value += (HDstrlen(dt->u.opaque.tag)+7) & 0xf8;
+            ret_value += (HDstrlen(dt->shared->u.opaque.tag)+7) & 0xf8;
             break;
 
         case H5T_FLOAT:
@@ -985,27 +1020,27 @@ H5O_dtype_size(H5F_t *f, const void *mesg)
             break;
 
         case H5T_COMPOUND:
-            for (i=0; i<dt->u.compnd.nmembs; i++) {
-                ret_value += ((HDstrlen(dt->u.compnd.memb[i].name) + 8) / 8) * 8;
+            for (i=0; i<dt->shared->u.compnd.nmembs; i++) {
+                ret_value += ((HDstrlen(dt->shared->u.compnd.memb[i].name) + 8) / 8) * 8;
                 ret_value += 4 +		/*member offset*/
                      1 +		/*dimensionality*/
                      3 +		/*reserved*/
                      4 +		/*permutation*/
                      4 +		/*reserved*/
                      16;		/*dimensions*/
-                ret_value += H5O_dtype_size(f, dt->u.compnd.memb[i].type);
+                ret_value += H5O_dtype_size(f, dt->shared->u.compnd.memb[i].type);
             }
             break;
 
         case H5T_ENUM:
-            ret_value += H5O_dtype_size(f, dt->parent);
-            for (i=0; i<dt->u.enumer.nmembs; i++)
-                ret_value += ((HDstrlen(dt->u.enumer.name[i])+8)/8)*8;
-            ret_value += dt->u.enumer.nmembs * dt->parent->size;
+            ret_value += H5O_dtype_size(f, dt->shared->parent);
+            for (i=0; i<dt->shared->u.enumer.nmembs; i++)
+                ret_value += ((HDstrlen(dt->shared->u.enumer.name[i])+8)/8)*8;
+            ret_value += dt->shared->u.enumer.nmembs * dt->shared->parent->shared->size;
             break;
 
         case H5T_VLEN:
-            ret_value += H5O_dtype_size(f, dt->parent);
+            ret_value += H5O_dtype_size(f, dt->shared->parent);
             break;
 
         case H5T_TIME:
@@ -1014,9 +1049,9 @@ H5O_dtype_size(H5F_t *f, const void *mesg)
 
         case H5T_ARRAY:
             ret_value += 4; /* ndims & reserved bytes*/
-            ret_value += 4*dt->u.array.ndims; /* dimensions */
-            ret_value += 4*dt->u.array.ndims; /* dimension permutations */
-            ret_value += H5O_dtype_size(f, dt->parent);
+            ret_value += 4*dt->shared->u.array.ndims; /* dimensions */
+            ret_value += 4*dt->shared->u.array.ndims; /* dimension permutations */
+            ret_value += H5O_dtype_size(f, dt->shared->parent);
             break;
 
         default:
@@ -1078,6 +1113,7 @@ H5O_dtype_free (void *mesg)
 
     assert (mesg);
 
+    H5FL_FREE(H5T_shared_t, ((H5T_t *) mesg)->shared);
     H5FL_FREE(H5T_t,mesg);
 
     FUNC_LEAVE_NOAPI(SUCCEED);
@@ -1112,7 +1148,7 @@ H5O_dtype_get_share(H5F_t UNUSED *f, const void *_mesg,
     assert (sh);
 
     if (H5F_addr_defined (dt->ent.header)) {
-	if(H5T_STATE_NAMED!=dt->state && H5T_STATE_OPEN!=dt->state && H5T_STATE_TRANSIENT!=dt->state)
+	if(H5T_STATE_NAMED!=dt->shared->state && H5T_STATE_OPEN!=dt->shared->state && H5T_STATE_TRANSIENT!=dt->shared->state)
 	    HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "datatype state is not valid");
 
 	sh->in_gh = FALSE;
@@ -1162,7 +1198,7 @@ H5O_dtype_set_share (H5F_t UNUSED *f, void *_mesg/*in,out*/,
     dt->ent.canon_path_r = NULL;
 
     /* Note that the datatype is a named datatype */
-    dt->state = H5T_STATE_NAMED;
+    dt->shared->state = H5T_STATE_NAMED;
 
     FUNC_LEAVE_NOAPI(SUCCEED);
 }
@@ -1206,7 +1242,7 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
     assert(indent >= 0);
     assert(fwidth >= 0);
 
-    switch (dt->type) {
+    switch (dt->shared->type) {
         case H5T_INTEGER:
             s = "integer";
             break;
@@ -1241,7 +1277,7 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
             s = "vlen";
             break;
         default:
-            sprintf(buf, "H5T_CLASS_%d", (int) (dt->type));
+            sprintf(buf, "H5T_CLASS_%d", (int) (dt->shared->type));
             s = buf;
             break;
     }
@@ -1251,51 +1287,51 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
 
     fprintf(stream, "%*s%-*s %lu byte%s\n", indent, "", fwidth,
 	    "Size:",
-	    (unsigned long)(dt->size), 1==dt->size?"":"s");
+	    (unsigned long)(dt->shared->size), 1==dt->shared->size?"":"s");
 
-    if (H5T_COMPOUND == dt->type) {
+    if (H5T_COMPOUND == dt->shared->type) {
 	fprintf(stream, "%*s%-*s %d\n", indent, "", fwidth,
 		"Number of members:",
-		dt->u.compnd.nmembs);
-	for (i=0; i<dt->u.compnd.nmembs; i++) {
+		dt->shared->u.compnd.nmembs);
+	for (i=0; i<dt->shared->u.compnd.nmembs; i++) {
 	    sprintf(buf, "Member %d:", i);
 	    fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
 		    buf,
-		    dt->u.compnd.memb[i].name);
+		    dt->shared->u.compnd.memb[i].name);
 	    fprintf(stream, "%*s%-*s %lu\n", indent+3, "", MAX(0, fwidth-3),
 		    "Byte offset:",
-		    (unsigned long) (dt->u.compnd.memb[i].offset));
-	    H5O_dtype_debug(f, dxpl_id, dt->u.compnd.memb[i].type, stream,
+		    (unsigned long) (dt->shared->u.compnd.memb[i].offset));
+	    H5O_dtype_debug(f, dxpl_id, dt->shared->u.compnd.memb[i].type, stream,
 			    indent+3, MAX(0, fwidth - 3));
 	}
-    } else if (H5T_ENUM==dt->type) {
+    } else if (H5T_ENUM==dt->shared->type) {
 	fprintf(stream, "%*s%s\n", indent, "", "Base type:");
-	H5O_dtype_debug(f, dxpl_id, dt->parent, stream, indent+3, MAX(0, fwidth-3));
+	H5O_dtype_debug(f, dxpl_id, dt->shared->parent, stream, indent+3, MAX(0, fwidth-3));
 	fprintf(stream, "%*s%-*s %d\n", indent, "", fwidth,
 		"Number of members:",
-		dt->u.enumer.nmembs);
-	for (i=0; i<dt->u.enumer.nmembs; i++) {
+		dt->shared->u.enumer.nmembs);
+	for (i=0; i<dt->shared->u.enumer.nmembs; i++) {
 	    sprintf(buf, "Member %d:", i);
 	    fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
 		    buf,
-		    dt->u.enumer.name[i]);
+		    dt->shared->u.enumer.name[i]);
 	    fprintf(stream, "%*s%-*s 0x", indent, "", fwidth,
 		    "Raw bytes of value:");
-	    for (k=0; k<dt->parent->size; k++) {
+	    for (k=0; k<dt->shared->parent->shared->size; k++) {
 		fprintf(stream, "%02x",
-			dt->u.enumer.value[i*dt->parent->size+k]);
+			dt->shared->u.enumer.value[i*dt->shared->parent->shared->size+k]);
 	    }
 	    fprintf(stream, "\n");
 	}
 	
-    } else if (H5T_OPAQUE==dt->type) {
+    } else if (H5T_OPAQUE==dt->shared->type) {
 	fprintf(stream, "%*s%-*s \"%s\"\n", indent, "", fwidth,
-		"Tag:", dt->u.opaque.tag);
-    } else if (H5T_REFERENCE==dt->type) {
+		"Tag:", dt->shared->u.opaque.tag);
+    } else if (H5T_REFERENCE==dt->shared->type) {
 	fprintf(stream, "%*s%-*s\n", indent, "", fwidth,
 		"Fix dumping reference types!");
-    } else if (H5T_VLEN==dt->type) {
-        switch (dt->u.vlen.type) {
+    } else if (H5T_VLEN==dt->shared->type) {
+        switch (dt->shared->u.vlen.type) {
             case H5T_VLEN_SEQUENCE:
                 s = "sequence";
                 break;
@@ -1303,14 +1339,14 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
                 s = "string";
                 break;
             default:
-                sprintf(buf, "H5T_VLEN_%d", dt->u.vlen.type);
+                sprintf(buf, "H5T_VLEN_%d", dt->shared->u.vlen.type);
                 s = buf;
                 break;
         }
         fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
                 "Vlen type:", s);
 
-        switch (dt->u.vlen.loc) {
+        switch (dt->shared->u.vlen.loc) {
             case H5T_LOC_MEMORY:
                 s = "memory";
                 break;
@@ -1318,30 +1354,30 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
                 s = "disk";
                 break;
             default:
-                sprintf(buf, "H5T_LOC_%d", dt->u.vlen.loc);
+                sprintf(buf, "H5T_LOC_%d", dt->shared->u.vlen.loc);
                 s = buf;
                 break;
         }
         fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
                 "Location:", s);
-    } else if (H5T_ARRAY==dt->type) {
+    } else if (H5T_ARRAY==dt->shared->type) {
 	fprintf(stream, "%*s%-*s %d\n", indent, "", fwidth,
 		"Rank:",
-		dt->u.array.ndims);
+		dt->shared->u.array.ndims);
     fprintf(stream, "%*s%-*s {", indent, "", fwidth, "Dim Size:");
-	for (i=0; i<(unsigned)dt->u.array.ndims; i++) {
-        fprintf (stream, "%s%u", i?", ":"", (unsigned)dt->u.array.dim[i]);
+	for (i=0; i<(unsigned)dt->shared->u.array.ndims; i++) {
+        fprintf (stream, "%s%u", i?", ":"", (unsigned)dt->shared->u.array.dim[i]);
     }
     fprintf (stream, "}\n");
     fprintf(stream, "%*s%-*s {", indent, "", fwidth, "Dim Permutation:");
-	for (i=0; i<(unsigned)dt->u.array.ndims; i++) {
-        fprintf (stream, "%s%d", i?", ":"", dt->u.array.perm[i]);
+	for (i=0; i<(unsigned)dt->shared->u.array.ndims; i++) {
+        fprintf (stream, "%s%d", i?", ":"", dt->shared->u.array.perm[i]);
     }
     fprintf (stream, "}\n");
 	fprintf(stream, "%*s%s\n", indent, "", "Base type:");
-	H5O_dtype_debug(f, dxpl_id, dt->parent, stream, indent+3, MAX(0, fwidth-3));
+	H5O_dtype_debug(f, dxpl_id, dt->shared->parent, stream, indent+3, MAX(0, fwidth-3));
     } else {
-	switch (dt->u.atomic.order) {
+	switch (dt->shared->u.atomic.order) {
             case H5T_ORDER_LE:
                 s = "little endian";
                 break;
@@ -1355,7 +1391,7 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
                 s = "none";
                 break;
             default:
-                sprintf(buf, "H5T_ORDER_%d", dt->u.atomic.order);
+                sprintf(buf, "H5T_ORDER_%d", dt->shared->u.atomic.order);
                 s = buf;
                 break;
 	}
@@ -1365,15 +1401,15 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
 
 	fprintf(stream, "%*s%-*s %lu bit%s\n", indent, "", fwidth,
 		"Precision:",
-		(unsigned long)(dt->u.atomic.prec),
-		1==dt->u.atomic.prec?"":"s");
+		(unsigned long)(dt->shared->u.atomic.prec),
+		1==dt->shared->u.atomic.prec?"":"s");
 
 	fprintf(stream, "%*s%-*s %lu bit%s\n", indent, "", fwidth,
 		"Offset:",
-		(unsigned long)(dt->u.atomic.offset),
-		1==dt->u.atomic.offset?"":"s");
+		(unsigned long)(dt->shared->u.atomic.offset),
+		1==dt->shared->u.atomic.offset?"":"s");
 
-	switch (dt->u.atomic.lsb_pad) {
+	switch (dt->shared->u.atomic.lsb_pad) {
             case H5T_PAD_ZERO:
                 s = "zero";
                 break;
@@ -1387,7 +1423,7 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
 	fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
 		"Low pad type:", s);
 
-	switch (dt->u.atomic.msb_pad) {
+	switch (dt->shared->u.atomic.msb_pad) {
             case H5T_PAD_ZERO:
                 s = "zero";
                 break;
@@ -1401,8 +1437,8 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
 	fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
 		"High pad type:", s);
 
-	if (H5T_FLOAT == dt->type) {
-	    switch (dt->u.atomic.u.f.pad) {
+	if (H5T_FLOAT == dt->shared->type) {
+	    switch (dt->shared->u.atomic.u.f.pad) {
                 case H5T_PAD_ZERO:
                     s = "zero";
                     break;
@@ -1410,10 +1446,10 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
                     s = "one";
                     break;
                 default:
-                    if (dt->u.atomic.u.f.pad < 0) {
-                        sprintf(buf, "H5T_PAD_%d", -(dt->u.atomic.u.f.pad));
+                    if (dt->shared->u.atomic.u.f.pad < 0) {
+                        sprintf(buf, "H5T_PAD_%d", -(dt->shared->u.atomic.u.f.pad));
                     } else {
-                        sprintf(buf, "bit-%d", dt->u.atomic.u.f.pad);
+                        sprintf(buf, "bit-%d", dt->shared->u.atomic.u.f.pad);
                     }
                     s = buf;
                     break;
@@ -1421,7 +1457,7 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
 	    fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
 		    "Internal pad type:", s);
 
-	    switch (dt->u.atomic.u.f.norm) {
+	    switch (dt->shared->u.atomic.u.f.norm) {
                 case H5T_NORM_IMPLIED:
                     s = "implied";
                     break;
@@ -1432,7 +1468,7 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
                     s = "none";
                     break;
                 default:
-                    sprintf(buf, "H5T_NORM_%d", (int) (dt->u.atomic.u.f.norm));
+                    sprintf(buf, "H5T_NORM_%d", (int) (dt->shared->u.atomic.u.f.norm));
                     s = buf;
 	    }
 	    fprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
@@ -1440,30 +1476,30 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
 
 	    fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
 		    "Sign bit location:",
-		    (unsigned long) (dt->u.atomic.u.f.sign));
+		    (unsigned long) (dt->shared->u.atomic.u.f.sign));
 
 	    fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
 		    "Exponent location:",
-		    (unsigned long) (dt->u.atomic.u.f.epos));
+		    (unsigned long) (dt->shared->u.atomic.u.f.epos));
 
 	    fprintf(stream, "%*s%-*s 0x%08lx\n", indent, "", fwidth,
 		    "Exponent bias:",
-		    (unsigned long) (dt->u.atomic.u.f.ebias));
+		    (unsigned long) (dt->shared->u.atomic.u.f.ebias));
 
 	    fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
 		    "Exponent size:",
-		    (unsigned long) (dt->u.atomic.u.f.esize));
+		    (unsigned long) (dt->shared->u.atomic.u.f.esize));
 
 	    fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
 		    "Mantissa location:",
-		    (unsigned long) (dt->u.atomic.u.f.mpos));
+		    (unsigned long) (dt->shared->u.atomic.u.f.mpos));
 
 	    fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
 		    "Mantissa size:",
-		    (unsigned long) (dt->u.atomic.u.f.msize));
+		    (unsigned long) (dt->shared->u.atomic.u.f.msize));
 
-	} else if (H5T_INTEGER == dt->type) {
-	    switch (dt->u.atomic.u.i.sign) {
+	} else if (H5T_INTEGER == dt->shared->type) {
+	    switch (dt->shared->u.atomic.u.i.sign) {
                 case H5T_SGN_NONE:
                     s = "none";
                     break;
@@ -1471,7 +1507,7 @@ H5O_dtype_debug(H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream,
                     s = "2's comp";
                     break;
                 default:
-                    sprintf(buf, "H5T_SGN_%d", (int) (dt->u.atomic.u.i.sign));
+                    sprintf(buf, "H5T_SGN_%d", (int) (dt->shared->u.atomic.u.i.sign));
                     s = buf;
                     break;
 	    }