mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 18:14:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

libctf: remove ctf_malloc, ctf_free and ctf_strdup

Browse Source 
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.
This commit is contained in:
Nick Alcock 2019-09-17 06:54:23 +01:00
parent 9c1a2295e8
commit de07e349be
11 changed files with 163 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/ChangeLog
View File

@ -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.

4
include/ctf-api.h
View File

@ -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);

43
libctf/ChangeLog
View File

@ -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

65
libctf/ctf-create.c
View File

@ -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;

12
libctf/ctf-decl.c
View File

@ -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;

8
libctf/ctf-dump.c
View File

@ -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;

6
libctf/ctf-impl.h
View File

@ -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);

92
libctf/ctf-open.c
View File

@ -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;

22
libctf/ctf-string.c
View File

@ -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)

12
libctf/ctf-subr.c
View File

@ -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)
{

13
libctf/ctf-util.c
View File

@ -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 *