aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorNick Alcock <nick.alcock@oracle.com>2019-09-17 06:54:23 +0100
committerNick Alcock <nick.alcock@oracle.com>2019-10-03 17:04:56 +0100
commitde07e349bea156484fae1dbec974fdbbf207d57d (patch)
tree6c05706f80ed06a2c71ef69aab121d1102aa73ed
parent9c1a2295e84170d2de06ef3c828f0c9f5933867e (diff)
downloadfsf-binutils-gdb-de07e349bea156484fae1dbec974fdbbf207d57d.zip
fsf-binutils-gdb-de07e349bea156484fae1dbec974fdbbf207d57d.tar.gz
fsf-binutils-gdb-de07e349bea156484fae1dbec974fdbbf207d57d.tar.bz2
libctf: remove ctf_malloc, ctf_free and ctf_strdup
These just get in the way of auditing for erroneous usage of strdup and add a huge irregular surface of "ctf_malloc or malloc? ctf_free or free? ctf_strdup or strdup?" ctf_malloc and ctf_free usage has not reliably matched up for many years, if ever, making the whole game pointless. Go back to malloc, free, and strdup like everyone else: while we're at it, fix a bunch of places where we weren't properly checking for OOM. This changes the interface of ctf_cuname_set and ctf_parent_name_set, which could strdup but could not return errors (like ENOMEM). New in v4. include/ * ctf-api.h (ctf_cuname_set): Can now fail, returning int. (ctf_parent_name_set): Likewise. libctf/ * ctf-impl.h (ctf_alloc): Remove. (ctf_free): Likewise. (ctf_strdup): Likewise. * ctf-subr.c (ctf_alloc): Remove. (ctf_free): Likewise. * ctf-util.c (ctf_strdup): Remove. * ctf-create.c (ctf_serialize): Use malloc, not ctf_alloc; free, not ctf_free; strdup, not ctf_strdup. (ctf_dtd_delete): Likewise. (ctf_dvd_delete): Likewise. (ctf_add_generic): Likewise. (ctf_add_function): Likewise. (ctf_add_enumerator): Likewise. (ctf_add_member_offset): Likewise. (ctf_add_variable): Likewise. (membadd): Likewise. (ctf_compress_write): Likewise. (ctf_write_mem): Likewise. * ctf-decl.c (ctf_decl_push): Likewise. (ctf_decl_fini): Likewise. (ctf_decl_sprintf): Likewise. Check for OOM. * ctf-dump.c (ctf_dump_append): Use malloc, not ctf_alloc; free, not ctf_free; strdup, not ctf_strdup. (ctf_dump_free): Likewise. (ctf_dump): Likewise. * ctf-open.c (upgrade_types_v1): Likewise. (init_types): Likewise. (ctf_file_close): Likewise. (ctf_bufopen_internal): Likewise. Check for OOM. (ctf_parent_name_set): Likewise: report the OOM to the caller. (ctf_cuname_set): Likewise. (ctf_import): Likewise. * ctf-string.c (ctf_str_purge_atom_refs): Use malloc, not ctf_alloc; free, not ctf_free; strdup, not ctf_strdup. (ctf_str_free_atom): Likewise. (ctf_str_create_atoms): Likewise. (ctf_str_add_ref_internal): Likewise. (ctf_str_remove_ref): Likewise. (ctf_str_write_strtab): Likewise.
-rw-r--r--include/ChangeLog5
-rw-r--r--include/ctf-api.h4
-rw-r--r--libctf/ChangeLog43
-rw-r--r--libctf/ctf-create.c65
-rw-r--r--libctf/ctf-decl.c12
-rw-r--r--libctf/ctf-dump.c8
-rw-r--r--libctf/ctf-impl.h6
-rw-r--r--libctf/ctf-open.c92
-rw-r--r--libctf/ctf-string.c22
-rw-r--r--libctf/ctf-subr.c12
-rw-r--r--libctf/ctf-util.c13
11 files changed, 163 insertions, 119 deletions
diff --git a/include/ChangeLog b/include/ChangeLog
index 1f95342..c409344 100644
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,3 +1,8 @@
+2019-09-23 Nick Alcock <nick.alcock@oracle.com>
+
+ * ctf-api.h (ctf_cuname_set): Can now fail, returning int.
+ (ctf_parent_name_set): Likewise.
+
2019-08-05 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (ECTF_NONREPRESENTABLE): New.
diff --git a/include/ctf-api.h b/include/ctf-api.h
index b83ddc7..d15b734 100644
--- a/include/ctf-api.h
+++ b/include/ctf-api.h
@@ -286,10 +286,10 @@ extern int ctf_arc_write_fd (int, ctf_file_t **, size_t, const char **,
size_t);
extern const char *ctf_cuname (ctf_file_t *);
-extern void ctf_cuname_set (ctf_file_t *, const char *);
+extern int ctf_cuname_set (ctf_file_t *, const char *);
extern ctf_file_t *ctf_parent_file (ctf_file_t *);
extern const char *ctf_parent_name (ctf_file_t *);
-extern void ctf_parent_name_set (ctf_file_t *, const char *);
+extern int ctf_parent_name_set (ctf_file_t *, const char *);
extern int ctf_type_isparent (ctf_file_t *, ctf_id_t);
extern int ctf_type_ischild (ctf_file_t *, ctf_id_t);
diff --git a/libctf/ChangeLog b/libctf/ChangeLog
index 74dfbef..85cd785 100644
--- a/libctf/ChangeLog
+++ b/libctf/ChangeLog
@@ -1,3 +1,46 @@
+2019-09-23 Nick Alcock <nick.alcock@oracle.com>
+
+ * ctf-impl.h (ctf_alloc): Remove.
+ (ctf_free): Likewise.
+ (ctf_strdup): Likewise.
+ * ctf-subr.c (ctf_alloc): Remove.
+ (ctf_free): Likewise.
+ * ctf-util.c (ctf_strdup): Remove.
+
+ * ctf-create.c (ctf_serialize): Use malloc, not ctf_alloc; free, not
+ ctf_free; strdup, not ctf_strdup.
+ (ctf_dtd_delete): Likewise.
+ (ctf_dvd_delete): Likewise.
+ (ctf_add_generic): Likewise.
+ (ctf_add_function): Likewise.
+ (ctf_add_enumerator): Likewise.
+ (ctf_add_member_offset): Likewise.
+ (ctf_add_variable): Likewise.
+ (membadd): Likewise.
+ (ctf_compress_write): Likewise.
+ (ctf_write_mem): Likewise.
+ * ctf-decl.c (ctf_decl_push): Likewise.
+ (ctf_decl_fini): Likewise.
+ (ctf_decl_sprintf): Likewise. Check for OOM.
+ * ctf-dump.c (ctf_dump_append): Use malloc, not ctf_alloc; free, not
+ ctf_free; strdup, not ctf_strdup.
+ (ctf_dump_free): Likewise.
+ (ctf_dump): Likewise.
+ * ctf-open.c (upgrade_types_v1): Likewise.
+ (init_types): Likewise.
+ (ctf_file_close): Likewise.
+ (ctf_bufopen_internal): Likewise. Check for OOM.
+ (ctf_parent_name_set): Likewise: report the OOM to the caller.
+ (ctf_cuname_set): Likewise.
+ (ctf_import): Likewise.
+ * ctf-string.c (ctf_str_purge_atom_refs): Use malloc, not ctf_alloc;
+ free, not ctf_free; strdup, not ctf_strdup.
+ (ctf_str_free_atom): Likewise.
+ (ctf_str_create_atoms): Likewise.
+ (ctf_str_add_ref_internal): Likewise.
+ (ctf_str_remove_ref): Likewise.
+ (ctf_str_write_strtab): Likewise.
+
2019-08-09 Nick Alcock <nick.alcock@oracle.com>
* ctf-types.c (ctf_type_encoding): Fix the dynamic case to
diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c
index 22635af..fa40100 100644
--- a/libctf/ctf-create.c
+++ b/libctf/ctf-create.c
@@ -479,7 +479,7 @@ ctf_serialize (ctf_file_t *fp)
if (strtab.cts_strs == NULL)
{
- ctf_free (buf);
+ free (buf);
return (ctf_set_errno (fp, EAGAIN));
}
@@ -491,8 +491,8 @@ ctf_serialize (ctf_file_t *fp)
if ((newbuf = ctf_realloc (fp, buf, buf_size + strtab.cts_len)) == NULL)
{
- ctf_free (buf);
- ctf_free (strtab.cts_strs);
+ free (buf);
+ free (strtab.cts_strs);
return (ctf_set_errno (fp, EAGAIN));
}
buf = newbuf;
@@ -500,7 +500,7 @@ ctf_serialize (ctf_file_t *fp)
hdrp = (ctf_header_t *) buf;
hdrp->cth_strlen = strtab.cts_len;
buf_size += hdrp->cth_strlen;
- ctf_free (strtab.cts_strs);
+ free (strtab.cts_strs);
/* Finally, we are ready to ctf_simple_open() the new container. If this
is successful, we then switch nfp and fp and free the old container. */
@@ -509,7 +509,7 @@ ctf_serialize (ctf_file_t *fp)
0, NULL, 0, fp->ctf_syn_ext_strtab,
1, &err)) == NULL)
{
- ctf_free (buf);
+ free (buf);
return (ctf_set_errno (fp, err));
}
@@ -635,13 +635,13 @@ ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
dmd != NULL; dmd = nmd)
{
if (dmd->dmd_name != NULL)
- ctf_free (dmd->dmd_name);
+ free (dmd->dmd_name);
nmd = ctf_list_next (dmd);
- ctf_free (dmd);
+ free (dmd);
}
break;
case CTF_K_FUNCTION:
- ctf_free (dtd->dtd_u.dtu_argv);
+ free (dtd->dtd_u.dtu_argv);
break;
}
@@ -654,7 +654,7 @@ ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
}
ctf_list_delete (&fp->ctf_dtdefs, dtd);
- ctf_free (dtd);
+ free (dtd);
}
ctf_dtdef_t *
@@ -694,10 +694,10 @@ void
ctf_dvd_delete (ctf_file_t *fp, ctf_dvdef_t *dvd)
{
ctf_dynhash_remove (fp->ctf_dvhash, dvd->dvd_name);
- ctf_free (dvd->dvd_name);
+ free (dvd->dvd_name);
ctf_list_delete (&fp->ctf_dvdefs, dvd);
- ctf_free (dvd);
+ free (dvd);
}
ctf_dvdef_t *
@@ -815,7 +815,7 @@ ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name, int kind,
if (ctf_grow_ptrtab (fp) < 0)
return CTF_ERR; /* errno is set for us. */
- if ((dtd = ctf_alloc (sizeof (ctf_dtdef_t))) == NULL)
+ if ((dtd = malloc (sizeof (ctf_dtdef_t))) == NULL)
return (ctf_set_errno (fp, EAGAIN));
type = ++fp->ctf_typemax;
@@ -827,13 +827,13 @@ ctf_add_generic (ctf_file_t *fp, uint32_t flag, const char *name, int kind,
if (dtd->dtd_data.ctt_name == 0 && name != NULL && name[0] != '\0')
{
- ctf_free (dtd);
+ free (dtd);
return (ctf_set_errno (fp, EAGAIN));
}
if (ctf_dtd_insert (fp, dtd, kind) < 0)
{
- ctf_free (dtd);
+ free (dtd);
return CTF_ERR; /* errno is set for us. */
}
fp->ctf_flags |= LCTF_DIRTY;
@@ -1066,13 +1066,13 @@ ctf_add_function (ctf_file_t *fp, uint32_t flag,
if (vlen > CTF_MAX_VLEN)
return (ctf_set_errno (fp, EOVERFLOW));
- if (vlen != 0 && (vdat = ctf_alloc (sizeof (ctf_id_t) * vlen)) == NULL)
+ if (vlen != 0 && (vdat = malloc (sizeof (ctf_id_t) * vlen)) == NULL)
return (ctf_set_errno (fp, EAGAIN));
if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
&dtd)) == CTF_ERR)
{
- ctf_free (vdat);
+ free (vdat);
return CTF_ERR; /* errno is set for us. */
}
@@ -1315,12 +1315,12 @@ ctf_add_enumerator (ctf_file_t *fp, ctf_id_t enid, const char *name,
return (ctf_set_errno (fp, ECTF_DUPLICATE));
}
- if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
+ if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
return (ctf_set_errno (fp, EAGAIN));
- if ((s = ctf_strdup (name)) == NULL)
+ if ((s = strdup (name)) == NULL)
{
- ctf_free (dmd);
+ free (dmd);
return (ctf_set_errno (fp, EAGAIN));
}
@@ -1378,12 +1378,12 @@ ctf_add_member_offset (ctf_file_t *fp, ctf_id_t souid, const char *name,
(malign = ctf_type_align (fp, type)) < 0)
return -1; /* errno is set for us. */
- if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
+ if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
return (ctf_set_errno (fp, EAGAIN));
- if (name != NULL && (s = ctf_strdup (name)) == NULL)
+ if (name != NULL && (s = strdup (name)) == NULL)
{
- ctf_free (dmd);
+ free (dmd);
return (ctf_set_errno (fp, EAGAIN));
}
@@ -1500,12 +1500,12 @@ ctf_add_variable (ctf_file_t *fp, const char *name, ctf_id_t ref)
&& (ctf_errno (fp) == ECTF_NONREPRESENTABLE))
return -1;
- if ((dvd = ctf_alloc (sizeof (ctf_dvdef_t))) == NULL)
+ if ((dvd = malloc (sizeof (ctf_dvdef_t))) == NULL)
return (ctf_set_errno (fp, EAGAIN));
- if (name != NULL && (dvd->dvd_name = ctf_strdup (name)) == NULL)
+ if (name != NULL && (dvd->dvd_name = strdup (name)) == NULL)
{
- ctf_free (dvd);
+ free (dvd);
return (ctf_set_errno (fp, EAGAIN));
}
dvd->dvd_type = ref;
@@ -1513,7 +1513,8 @@ ctf_add_variable (ctf_file_t *fp, const char *name, ctf_id_t ref)
if (ctf_dvd_insert (fp, dvd) < 0)
{
- ctf_free (dvd);
+ free (dvd->dvd_name);
+ free (dvd);
return -1; /* errno is set for us. */
}
@@ -1580,12 +1581,12 @@ membadd (const char *name, ctf_id_t type, unsigned long offset, void *arg)
ctf_dmdef_t *dmd;
char *s = NULL;
- if ((dmd = ctf_alloc (sizeof (ctf_dmdef_t))) == NULL)
+ if ((dmd = malloc (sizeof (ctf_dmdef_t))) == NULL)
return (ctf_set_errno (ctb->ctb_file, EAGAIN));
- if (name != NULL && (s = ctf_strdup (name)) == NULL)
+ if (name != NULL && (s = strdup (name)) == NULL)
{
- ctf_free (dmd);
+ free (dmd);
return (ctf_set_errno (ctb->ctb_file, EAGAIN));
}
@@ -2115,7 +2116,7 @@ ctf_compress_write (ctf_file_t *fp, int fd)
hp->cth_flags |= CTF_F_COMPRESS;
compress_len = compressBound (fp->ctf_size);
- if ((buf = ctf_alloc (compress_len)) == NULL)
+ if ((buf = malloc (compress_len)) == NULL)
return (ctf_set_errno (fp, ECTF_ZALLOC));
if ((rc = compress (buf, (uLongf *) &compress_len,
@@ -2150,7 +2151,7 @@ ctf_compress_write (ctf_file_t *fp, int fd)
}
ret:
- ctf_free (buf);
+ free (buf);
return err;
}
@@ -2198,7 +2199,7 @@ ctf_write_mem (ctf_file_t *fp, size_t *size, size_t threshold)
{
ctf_dprintf ("zlib deflate err: %s\n", zError (rc));
ctf_set_errno (fp, ECTF_COMPRESS);
- ctf_free (buf);
+ free (buf);
return NULL;
}
*size += compress_len;
diff --git a/libctf/ctf-decl.c b/libctf/ctf-decl.c
index c85982e..584bd5e 100644
--- a/libctf/ctf-decl.c
+++ b/libctf/ctf-decl.c
@@ -65,7 +65,7 @@ ctf_decl_fini (ctf_decl_t *cd)
for (cdp = ctf_list_next (&cd->cd_nodes[i]); cdp != NULL; cdp = ndp)
{
ndp = ctf_list_next (cdp);
- ctf_free (cdp);
+ free (cdp);
}
}
}
@@ -132,7 +132,7 @@ ctf_decl_push (ctf_decl_t *cd, ctf_file_t *fp, ctf_id_t type)
prec = CTF_PREC_BASE;
}
- if ((cdp = ctf_alloc (sizeof (ctf_decl_node_t))) == NULL)
+ if ((cdp = malloc (sizeof (ctf_decl_node_t))) == NULL)
{
cd->cd_err = EAGAIN;
return;
@@ -176,10 +176,14 @@ void ctf_decl_sprintf (ctf_decl_t *cd, const char *format, ...)
va_end (ap);
if (n > 0)
- cd->cd_buf = ctf_str_append (cd->cd_buf, str);
+ {
+ char *newbuf;
+ if ((newbuf = ctf_str_append (cd->cd_buf, str)) != NULL)
+ cd->cd_buf = newbuf;
+ }
/* Sticky error condition. */
- if (n < 0)
+ if (n < 0 || cd->cd_buf == NULL)
{
free (cd->cd_buf);
cd->cd_buf = NULL;
diff --git a/libctf/ctf-dump.c b/libctf/ctf-dump.c
index df08f0b..c2d331b 100644
--- a/libctf/ctf-dump.c
+++ b/libctf/ctf-dump.c
@@ -52,7 +52,7 @@ ctf_dump_append (ctf_dump_state_t *state, char *str)
{
ctf_dump_item_t *cdi;
- if ((cdi = ctf_alloc (sizeof (struct ctf_dump_item))) == NULL)
+ if ((cdi = malloc (sizeof (struct ctf_dump_item))) == NULL)
return (ctf_set_errno (state->cds_fp, ENOMEM));
cdi->cdi_item = str;
@@ -73,7 +73,7 @@ ctf_dump_free (ctf_dump_state_t *state)
{
free (cdi->cdi_item);
next_cdi = ctf_list_next (cdi);
- ctf_free (cdi);
+ free (cdi);
}
}
@@ -668,7 +668,7 @@ ctf_dump (ctf_file_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
by bit. The first call will take (much) longer than otherwise, but the
amortized time needed is the same. */
- if ((*statep = ctf_alloc (sizeof (struct ctf_dump_state))) == NULL)
+ if ((*statep = malloc (sizeof (struct ctf_dump_state))) == NULL)
{
ctf_set_errno (fp, ENOMEM);
goto end;
@@ -779,7 +779,7 @@ ctf_dump (ctf_file_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
end:
ctf_dump_free (state);
- ctf_free (state);
+ free (state);
ctf_set_errno (fp, 0);
*statep = NULL;
return NULL;
diff --git a/libctf/ctf-impl.h b/libctf/ctf-impl.h
index f8e9a77..bed34876 100644
--- a/libctf/ctf-impl.h
+++ b/libctf/ctf-impl.h
@@ -455,13 +455,7 @@ extern void *ctf_mmap (size_t length, size_t offset, int fd);
extern void ctf_munmap (void *, size_t);
extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset);
-_libctf_malloc_
-extern void *ctf_alloc (size_t);
-extern void ctf_free (void *);
extern void *ctf_realloc (ctf_file_t *, void *, size_t);
-
-_libctf_malloc_
-extern char *ctf_strdup (const char *);
extern char *ctf_str_append (char *, const char *);
extern const char *ctf_strerror (int);
diff --git a/libctf/ctf-open.c b/libctf/ctf-open.c
index b698957..4a95b7f 100644
--- a/libctf/ctf-open.c
+++ b/libctf/ctf-open.c
@@ -446,7 +446,7 @@ upgrade_types_v1 (ctf_file_t *fp, ctf_header_t *cth)
number unchanged, so that LCTF_INFO_* still works on the
as-yet-untranslated type info. */
- if ((ctf_base = ctf_alloc (fp->ctf_size + increase)) == NULL)
+ if ((ctf_base = malloc (fp->ctf_size + increase)) == NULL)
return ECTF_ZALLOC;
/* Start at ctf_buf, not ctf_base, to squeeze out the original header: we
@@ -613,7 +613,7 @@ upgrade_types_v1 (ctf_file_t *fp, ctf_header_t *cth)
assert ((size_t) t2p - (size_t) fp->ctf_buf == cth->cth_stroff);
ctf_set_version (fp, cth, CTF_VERSION_1_UPGRADED_3);
- ctf_free (old_ctf_base);
+ free (old_ctf_base);
return 0;
}
@@ -746,9 +746,9 @@ init_types (ctf_file_t *fp, ctf_header_t *cth)
ctf_hash_eq_string)) == NULL)
return ENOMEM;
- fp->ctf_txlate = ctf_alloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
+ fp->ctf_txlate = malloc (sizeof (uint32_t) * (fp->ctf_typemax + 1));
fp->ctf_ptrtab_len = fp->ctf_typemax + 1;
- fp->ctf_ptrtab = ctf_alloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
+ fp->ctf_ptrtab = malloc (sizeof (uint32_t) * fp->ctf_ptrtab_len);
if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
return ENOMEM; /* Memory allocation failed. */
@@ -1370,7 +1370,7 @@ ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
if (ctfsect->cts_size < hdrsz)
return (ctf_set_open_errno (errp, ECTF_NOCTFBUF));
- if ((fp = ctf_alloc (sizeof (ctf_file_t))) == NULL)
+ if ((fp = malloc (sizeof (ctf_file_t))) == NULL)
return (ctf_set_open_errno (errp, ENOMEM));
memset (fp, 0, sizeof (ctf_file_t));
@@ -1378,9 +1378,9 @@ ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
if (writable)
fp->ctf_flags |= LCTF_RDWR;
- if ((fp->ctf_header = ctf_alloc (sizeof (struct ctf_header))) == NULL)
+ if ((fp->ctf_header = malloc (sizeof (struct ctf_header))) == NULL)
{
- ctf_free (fp);
+ free (fp);
return (ctf_set_open_errno (errp, ENOMEM));
}
hp = fp->ctf_header;
@@ -1435,7 +1435,7 @@ ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
/* We are allocating this ourselves, so we can drop the ctf header
copy in favour of ctf->ctf_header. */
- if ((fp->ctf_base = ctf_alloc (fp->ctf_size)) == NULL)
+ if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
{
err = ECTF_ZALLOC;
goto bad;
@@ -1466,7 +1466,7 @@ ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
}
else if (foreign_endian)
{
- if ((fp->ctf_base = ctf_alloc (fp->ctf_size)) == NULL)
+ if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL)
{
err = ECTF_ZALLOC;
goto bad;
@@ -1506,11 +1506,23 @@ ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
}
if (fp->ctf_data.cts_name != NULL)
- fp->ctf_data.cts_name = ctf_strdup (fp->ctf_data.cts_name);
+ if ((fp->ctf_data.cts_name = strdup (fp->ctf_data.cts_name)) == NULL)
+ {
+ err = ENOMEM;
+ goto bad;
+ }
if (fp->ctf_symtab.cts_name != NULL)
- fp->ctf_symtab.cts_name = ctf_strdup (fp->ctf_symtab.cts_name);
+ if ((fp->ctf_symtab.cts_name = strdup (fp->ctf_symtab.cts_name)) == NULL)
+ {
+ err = ENOMEM;
+ goto bad;
+ }
if (fp->ctf_strtab.cts_name != NULL)
- fp->ctf_strtab.cts_name = ctf_strdup (fp->ctf_strtab.cts_name);
+ if ((fp->ctf_strtab.cts_name = strdup (fp->ctf_strtab.cts_name)) == NULL)
+ {
+ err = ENOMEM;
+ goto bad;
+ }
if (fp->ctf_data.cts_name == NULL)
fp->ctf_data.cts_name = _CTF_NULLSTR;
@@ -1558,7 +1570,7 @@ ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
if (symsect != NULL)
{
fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize;
- fp->ctf_sxlate = ctf_alloc (fp->ctf_nsyms * sizeof (uint32_t));
+ fp->ctf_sxlate = malloc (fp->ctf_nsyms * sizeof (uint32_t));
if (fp->ctf_sxlate == NULL)
{
@@ -1613,8 +1625,8 @@ ctf_file_close (ctf_file_t *fp)
return;
}
- ctf_free (fp->ctf_dyncuname);
- ctf_free (fp->ctf_dynparname);
+ free (fp->ctf_dyncuname);
+ free (fp->ctf_dynparname);
ctf_file_close (fp->ctf_parent);
for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd)
@@ -1645,20 +1657,20 @@ ctf_file_close (ctf_file_t *fp)
}
ctf_dynhash_destroy (fp->ctf_dvhash);
ctf_str_free_atoms (fp);
- ctf_free (fp->ctf_tmp_typeslice);
+ free (fp->ctf_tmp_typeslice);
if (fp->ctf_data.cts_name != _CTF_NULLSTR)
- ctf_free ((char *) fp->ctf_data.cts_name);
+ free ((char *) fp->ctf_data.cts_name);
if (fp->ctf_symtab.cts_name != _CTF_NULLSTR)
- ctf_free ((char *) fp->ctf_symtab.cts_name);
+ free ((char *) fp->ctf_symtab.cts_name);
if (fp->ctf_strtab.cts_name != _CTF_NULLSTR)
- ctf_free ((char *) fp->ctf_strtab.cts_name);
+ free ((char *) fp->ctf_strtab.cts_name);
else if (fp->ctf_data_mmapped)
ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len);
- ctf_free (fp->ctf_dynbase);
+ free (fp->ctf_dynbase);
ctf_dynhash_destroy (fp->ctf_syn_ext_strtab);
ctf_dynhash_destroy (fp->ctf_link_inputs);
@@ -1667,12 +1679,12 @@ ctf_file_close (ctf_file_t *fp)
ctf_dynhash_destroy (fp->ctf_link_cu_mapping);
ctf_dynhash_destroy (fp->ctf_add_processing);
- ctf_free (fp->ctf_sxlate);
- ctf_free (fp->ctf_txlate);
- ctf_free (fp->ctf_ptrtab);
+ free (fp->ctf_sxlate);
+ free (fp->ctf_txlate);
+ free (fp->ctf_ptrtab);
- ctf_free (fp->ctf_header);
- ctf_free (fp);
+ free (fp->ctf_header);
+ free (fp);
}
/* The converse of ctf_open(). ctf_open() disguises whatever it opens as an
@@ -1719,14 +1731,16 @@ ctf_parent_name (ctf_file_t *fp)
/* Set the parent name. It is an error to call this routine without calling
ctf_import() at some point. */
-void
+int
ctf_parent_name_set (ctf_file_t *fp, const char *name)
{
if (fp->ctf_dynparname != NULL)
- ctf_free (fp->ctf_dynparname);
+ free (fp->ctf_dynparname);
- fp->ctf_dynparname = ctf_strdup (name);
+ if ((fp->ctf_dynparname = strdup (name)) == NULL)
+ return (ctf_set_errno (fp, ENOMEM));
fp->ctf_parname = fp->ctf_dynparname;
+ return 0;
}
/* Return the name of the compilation unit this CTF file applies to. Usually
@@ -1738,14 +1752,16 @@ ctf_cuname (ctf_file_t *fp)
}
/* Set the compilation unit name. */
-void
+int
ctf_cuname_set (ctf_file_t *fp, const char *name)
{
if (fp->ctf_dyncuname != NULL)
- ctf_free (fp->ctf_dyncuname);
+ free (fp->ctf_dyncuname);
- fp->ctf_dyncuname = ctf_strdup (name);
+ if ((fp->ctf_dyncuname = strdup (name)) == NULL)
+ return (ctf_set_errno (fp, ENOMEM));
fp->ctf_cuname = fp->ctf_dyncuname;
+ return 0;
}
/* Import the types from the specified parent container by storing a pointer
@@ -1761,15 +1777,21 @@ ctf_import (ctf_file_t *fp, ctf_file_t *pfp)
return (ctf_set_errno (fp, ECTF_DMODEL));
if (fp->ctf_parent != NULL)
- ctf_file_close (fp->ctf_parent);
+ {
+ ctf_file_close (fp->ctf_parent);
+ fp->ctf_parent = NULL;
+ }
if (pfp != NULL)
{
- fp->ctf_flags |= LCTF_CHILD;
- pfp->ctf_refcnt++;
+ int err;
if (fp->ctf_parname == NULL)
- ctf_parent_name_set (fp, "PARENT");
+ if ((err = ctf_parent_name_set (fp, "PARENT")) < 0)
+ return err;
+
+ fp->ctf_flags |= LCTF_CHILD;
+ pfp->ctf_refcnt++;
}
fp->ctf_parent = pfp;
return 0;
diff --git a/libctf/ctf-string.c b/libctf/ctf-string.c
index 243e1ac..a4227f9 100644
--- a/libctf/ctf-string.c
+++ b/libctf/ctf-string.c
@@ -82,7 +82,7 @@ ctf_str_purge_atom_refs (ctf_str_atom_t *atom)
{
next = ctf_list_next (ref);
ctf_list_delete (&atom->csa_refs, ref);
- ctf_free (ref);
+ free (ref);
}
}
@@ -93,7 +93,7 @@ ctf_str_free_atom (void *a)
ctf_str_atom_t *atom = a;
ctf_str_purge_atom_refs (atom);
- ctf_free (atom);
+ free (atom);
}
/* Create the atoms table. There is always at least one atom in it, the null
@@ -102,7 +102,7 @@ int
ctf_str_create_atoms (ctf_file_t *fp)
{
fp->ctf_str_atoms = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string,
- ctf_free, ctf_str_free_atom);
+ free, ctf_str_free_atom);
if (fp->ctf_str_atoms == NULL)
return -ENOMEM;
@@ -154,7 +154,7 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
if (add_ref)
{
- if ((aref = ctf_alloc (sizeof (struct ctf_str_atom_ref))) == NULL)
+ if ((aref = malloc (sizeof (struct ctf_str_atom_ref))) == NULL)
return NULL;
aref->caf_ref = ref;
}
@@ -169,11 +169,11 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
return atom;
}
- if ((atom = ctf_alloc (sizeof (struct ctf_str_atom))) == NULL)
+ if ((atom = malloc (sizeof (struct ctf_str_atom))) == NULL)
goto oom;
memset (atom, 0, sizeof (struct ctf_str_atom));
- if ((newstr = ctf_strdup (str)) == NULL)
+ if ((newstr = strdup (str)) == NULL)
goto oom;
if (ctf_dynhash_insert (fp->ctf_str_atoms, newstr, atom) < 0)
@@ -203,9 +203,9 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
oom:
if (newstr)
ctf_dynhash_remove (fp->ctf_str_atoms, newstr);
- ctf_free (atom);
- ctf_free (aref);
- ctf_free (newstr);
+ free (atom);
+ free (aref);
+ free (newstr);
return NULL;
}
@@ -279,7 +279,7 @@ ctf_str_remove_ref (ctf_file_t *fp, const char *str, uint32_t *ref)
if (aref->caf_ref == ref)
{
ctf_list_delete (&atom->csa_refs, aref);
- ctf_free (aref);
+ free (aref);
}
}
}
@@ -452,7 +452,7 @@ ctf_str_write_strtab (ctf_file_t *fp)
qsort (&sorttab[1], s.strtab_count - 1, sizeof (ctf_str_atom_t *),
ctf_str_sort_strtab);
- if ((strtab.cts_strs = ctf_alloc (strtab.cts_len)) == NULL)
+ if ((strtab.cts_strs = malloc (strtab.cts_len)) == NULL)
goto oom_sorttab;
if (!fp->ctf_syn_ext_strtab)
diff --git a/libctf/ctf-subr.c b/libctf/ctf-subr.c
index 454716a..6bd7f10 100644
--- a/libctf/ctf-subr.c
+++ b/libctf/ctf-subr.c
@@ -65,18 +65,6 @@ ctf_munmap (void *buf, size_t length _libctf_unused_)
#endif
}
-_libctf_malloc_ void *
-ctf_alloc (size_t size)
-{
- return (malloc (size));
-}
-
-void
-ctf_free (void *buf)
-{
- free (buf);
-}
-
ssize_t
ctf_pread (int fd, void *buf, ssize_t count, off_t offset)
{
diff --git a/libctf/ctf-util.c b/libctf/ctf-util.c
index f27c768..d10b2b5 100644
--- a/libctf/ctf-util.c
+++ b/libctf/ctf-util.c
@@ -103,19 +103,6 @@ ctf_sym_to_elf64 (const Elf32_Sym *src, Elf64_Sym *dst)
return dst;
}
-/* Same as strdup(3C), but use ctf_alloc() to do the memory allocation. */
-
-_libctf_malloc_ char *
-ctf_strdup (const char *s1)
-{
- char *s2 = ctf_alloc (strlen (s1) + 1);
-
- if (s2 != NULL)
- (void) strcpy (s2, s1);
-
- return s2;
-}
-
/* A string appender working on dynamic strings. */
char *