libctf: eliminate dtd_u, part 2: arrays

This is even simpler than ints, floats and slices, with the only extra
complication being the need to manually transfer the array parameter in
the rarely-used function ctf_set_array.  (Arrays are unique in libctf in
that they can be modified post facto, not just created and appended to.
I'm not sure why they got this exemption, but it's easy to maintain.)

libctf/ChangeLog
2021-03-18  Nick Alcock  <nick.alcock@oracle.com>

	* ctf-impl.h (ctf_dtdef_t) <dtd_u.dtu_arr>: Remove.
	* ctf-create.c (ctf_add_array): Use the dtd_vlen, not dtu_arr.
	(ctf_set_array): Likewise.
	* ctf-serialize.c (ctf_emit_type_sect): Just copy the dtd_vlen.
	* ctf-types.c (ctf_array_info): Just use the vlen.

diff --git a/libctf/ChangeLog b/libctf/ChangeLog
index bf138399a393d6cc118fde3d424b95cc20b2a8e7..25a32d2a658f00d6afcff912b702c88df5146672 100644 (file)
--- a/libctf/ChangeLog
+++ b/libctf/ChangeLog
@@ -1,3 +1,11 @@
+2021-03-18  Nick Alcock  <nick.alcock@oracle.com>
+
+       * ctf-impl.h (ctf_dtdef_t) <dtd_u.dtu_arr>: Remove.
+       * ctf-create.c (ctf_add_array): Use the dtd_vlen, not dtu_arr.
+       (ctf_set_array): Likewise.
+       * ctf-serialize.c (ctf_emit_type_sect): Just copy the dtd_vlen.
+       * ctf-types.c (ctf_array_info): Just use the vlen.
+
 2021-03-18  Nick Alcock  <nick.alcock@oracle.com>
 
        * ctf-impl.h (ctf_dtdef_t) <dtd_u.dtu_enc>: Remove.

diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c
index 90db7121af6bfd4545a7bce9fc656f7144fa1d6a..bc46cfa6ca80ea4ec2b62b79b190e6965c417563 100644 (file)
--- a/libctf/ctf-create.c
+++ b/libctf/ctf-create.c
@@ -635,6 +635,7 @@ ctf_id_t
 ctf_add_array (ctf_dict_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
 {
   ctf_dtdef_t *dtd;
+  ctf_array_t cta;
   ctf_id_t type;
   ctf_dict_t *tmp = fp;
 
@@ -658,12 +659,17 @@ ctf_add_array (ctf_dict_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
     }
 
   if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY,
-                              0, &dtd)) == CTF_ERR)
+                              sizeof (ctf_array_t), &dtd)) == CTF_ERR)
     return CTF_ERR;            /* errno is set for us.  */
 
+  memset (&cta, 0, sizeof (ctf_array_t));
+
   dtd->dtd_data.ctt_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
   dtd->dtd_data.ctt_size = 0;
-  dtd->dtd_u.dtu_arr = *arp;
+  cta.cta_contents = (uint32_t) arp->ctr_contents;
+  cta.cta_index = (uint32_t) arp->ctr_index;
+  cta.cta_nelems = arp->ctr_nelems;
+  memcpy (dtd->dtd_vlen, &cta, sizeof (ctf_array_t));
 
   return type;
 }
@@ -672,6 +678,7 @@ int
 ctf_set_array (ctf_dict_t *fp, ctf_id_t type, const ctf_arinfo_t *arp)
 {
   ctf_dtdef_t *dtd = ctf_dtd_lookup (fp, type);
+  ctf_array_t *vlen;
 
   if (!(fp->ctf_flags & LCTF_RDWR))
     return (ctf_set_errno (fp, ECTF_RDONLY));
@@ -680,8 +687,11 @@ ctf_set_array (ctf_dict_t *fp, ctf_id_t type, const ctf_arinfo_t *arp)
       || LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) != CTF_K_ARRAY)
     return (ctf_set_errno (fp, ECTF_BADID));
 
+  vlen = (ctf_array_t *) dtd->dtd_vlen;
   fp->ctf_flags |= LCTF_DIRTY;
-  dtd->dtd_u.dtu_arr = *arp;
+  vlen->cta_contents = (uint32_t) arp->ctr_contents;
+  vlen->cta_index = (uint32_t) arp->ctr_index;
+  vlen->cta_nelems = arp->ctr_nelems;
 
   return 0;
 }

diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index 742b4b37affd0eea4db52ba131c709a738adf318..c1ce50bc3b95e6df1f10c7d47638284e05dd9c83 100644 (file)
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -196,7 +196,6 @@ typedef struct ctf_dtdef
   union
   {
     ctf_list_t dtu_members;    /* struct, union, or enum */
-    ctf_arinfo_t dtu_arr;      /* array */
     uint32_t *dtu_argv;                /* function */
   } dtd_u;
 } ctf_dtdef_t;

diff --git a/libctf/ctf-serialize.c b/libctf/ctf-serialize.c
index f07cb61c42aa2bc7a7164eebfe0d8437ad69cd23..d8e78f361f40f536de64c0e45b27d07a093f4bbd 100644 (file)
--- a/libctf/ctf-serialize.c
+++ b/libctf/ctf-serialize.c
@@ -857,7 +857,6 @@ ctf_emit_type_sect (ctf_dict_t *fp, unsigned char **tptr)
       uint32_t kind = LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info);
       uint32_t vlen = LCTF_INFO_VLEN (fp, dtd->dtd_data.ctt_info);
 
-      ctf_array_t cta;
       size_t len;
       ctf_stype_t *copied;
       const char *name;
@@ -888,11 +887,8 @@ ctf_emit_type_sect (ctf_dict_t *fp, unsigned char **tptr)
          break;
 
        case CTF_K_ARRAY:
-         cta.cta_contents = (uint32_t) dtd->dtd_u.dtu_arr.ctr_contents;
-         cta.cta_index = (uint32_t) dtd->dtd_u.dtu_arr.ctr_index;
-         cta.cta_nelems = dtd->dtd_u.dtu_arr.ctr_nelems;
-         memcpy (t, &cta, sizeof (cta));
-         t += sizeof (cta);
+         memcpy (t, dtd->dtd_vlen, sizeof (struct ctf_array));
+         t += sizeof (struct ctf_array);
          break;
 
        case CTF_K_FUNCTION:

diff --git a/libctf/ctf-types.c b/libctf/ctf-types.c
index ae2438177131aa6787cf7e355c2f3c63bb854377..8c983d5542fb4d2a489bdbb2795abac69eb89b83 100644 (file)
--- a/libctf/ctf-types.c
+++ b/libctf/ctf-types.c
@@ -1520,14 +1520,12 @@ ctf_array_info (ctf_dict_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
     return (ctf_set_errno (ofp, ECTF_NOTARRAY));
 
   if ((dtd = ctf_dynamic_type (ofp, type)) != NULL)
+    ap = (const ctf_array_t *) dtd->dtd_vlen;
+  else
     {
-      *arp = dtd->dtd_u.dtu_arr;
-      return 0;
+      ctf_get_ctt_size (fp, tp, NULL, &increment);
+      ap = (const ctf_array_t *) ((uintptr_t) tp + increment);
     }
-
-  (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
-
-  ap = (const ctf_array_t *) ((uintptr_t) tp + increment);
   arp->ctr_contents = ap->cta_contents;
   arp->ctr_index = ap->cta_index;
   arp->ctr_nelems = ap->cta_nelems;