espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-07-15 05:01:13 +08:00
Code Issues 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
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> 2019-08-05 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (ECTF_NONREPRESENTABLE): New. * 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); size_t);
extern const char *ctf_cuname (ctf_file_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 ctf_file_t *ctf_parent_file (ctf_file_t *);
extern const char *ctf_parent_name (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_isparent (ctf_file_t *, ctf_id_t);
extern int ctf_type_ischild (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> 2019-08-09 Nick Alcock <nick.alcock@oracle.com>
* ctf-types.c (ctf_type_encoding): Fix the dynamic case to * 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) if (strtab.cts_strs == NULL)
{ {
ctf_free (buf); free (buf);
return (ctf_set_errno (fp, EAGAIN)); 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) if ((newbuf = ctf_realloc (fp, buf, buf_size + strtab.cts_len)) == NULL)
{ {
ctf_free (buf); free (buf);
ctf_free (strtab.cts_strs); free (strtab.cts_strs);
return (ctf_set_errno (fp, EAGAIN)); return (ctf_set_errno (fp, EAGAIN));
} }
buf = newbuf; buf = newbuf;
@ -500,7 +500,7 @@ ctf_serialize (ctf_file_t *fp)
hdrp = (ctf_header_t *) buf; hdrp = (ctf_header_t *) buf;
hdrp->cth_strlen = strtab.cts_len; hdrp->cth_strlen = strtab.cts_len;
buf_size += hdrp->cth_strlen; 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 /* 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. */ 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, 0, NULL, 0, fp->ctf_syn_ext_strtab,
1, &err)) == NULL) 1, &err)) == NULL)
{ {
ctf_free (buf); free (buf);
return (ctf_set_errno (fp, err)); 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) dmd != NULL; dmd = nmd)
{ {
if (dmd->dmd_name != NULL) if (dmd->dmd_name != NULL)
ctf_free (dmd->dmd_name); free (dmd->dmd_name);
nmd = ctf_list_next (dmd); nmd = ctf_list_next (dmd);
ctf_free (dmd); free (dmd);
} }
break; break;
case CTF_K_FUNCTION: case CTF_K_FUNCTION:
ctf_free (dtd->dtd_u.dtu_argv); free (dtd->dtd_u.dtu_argv);
break; break;
} }
@ -654,7 +654,7 @@ ctf_dtd_delete (ctf_file_t *fp, ctf_dtdef_t *dtd)
} }
ctf_list_delete (&fp->ctf_dtdefs, dtd); ctf_list_delete (&fp->ctf_dtdefs, dtd);
ctf_free (dtd); free (dtd);
} }
ctf_dtdef_t * ctf_dtdef_t *
@ -694,10 +694,10 @@ void
ctf_dvd_delete (ctf_file_t *fp, ctf_dvdef_t *dvd) ctf_dvd_delete (ctf_file_t *fp, ctf_dvdef_t *dvd)
{ {
ctf_dynhash_remove (fp->ctf_dvhash, dvd->dvd_name); 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_list_delete (&fp->ctf_dvdefs, dvd);
ctf_free (dvd); free (dvd);
} }
ctf_dvdef_t * 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) if (ctf_grow_ptrtab (fp) < 0)
return CTF_ERR; /* errno is set for us. */ 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)); return (ctf_set_errno (fp, EAGAIN));
type = ++fp->ctf_typemax; 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') if (dtd->dtd_data.ctt_name == 0 && name != NULL && name[0] != '\0')
{ {
ctf_free (dtd); free (dtd);
return (ctf_set_errno (fp, EAGAIN)); return (ctf_set_errno (fp, EAGAIN));
} }
if (ctf_dtd_insert (fp, dtd, kind) < 0) if (ctf_dtd_insert (fp, dtd, kind) < 0)
{ {
ctf_free (dtd); free (dtd);
return CTF_ERR; /* errno is set for us. */ return CTF_ERR; /* errno is set for us. */
} }
fp->ctf_flags |= LCTF_DIRTY; fp->ctf_flags |= LCTF_DIRTY;
@ -1066,13 +1066,13 @@ ctf_add_function (ctf_file_t *fp, uint32_t flag,
if (vlen > CTF_MAX_VLEN) if (vlen > CTF_MAX_VLEN)
return (ctf_set_errno (fp, EOVERFLOW)); 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)); return (ctf_set_errno (fp, EAGAIN));
if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION, if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_FUNCTION,
&dtd)) == CTF_ERR) &dtd)) == CTF_ERR)
{ {
ctf_free (vdat); free (vdat);
return CTF_ERR; /* errno is set for us. */ 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)); 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)); 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)); 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) (malign = ctf_type_align (fp, type)) < 0)
return -1; /* errno is set for us. */ 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)); 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)); 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)) && (ctf_errno (fp) == ECTF_NONREPRESENTABLE))
return -1; 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)); 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)); return (ctf_set_errno (fp, EAGAIN));
} }
dvd->dvd_type = ref; 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) if (ctf_dvd_insert (fp, dvd) < 0)
{ {
ctf_free (dvd); free (dvd->dvd_name);
free (dvd);
return -1; /* errno is set for us. */ 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; ctf_dmdef_t *dmd;
char *s = NULL; 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)); 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)); 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; hp->cth_flags |= CTF_F_COMPRESS;
compress_len = compressBound (fp->ctf_size); 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)); return (ctf_set_errno (fp, ECTF_ZALLOC));
if ((rc = compress (buf, (uLongf *) &compress_len, if ((rc = compress (buf, (uLongf *) &compress_len,
@ -2150,7 +2151,7 @@ ctf_compress_write (ctf_file_t *fp, int fd)
} }
ret: ret:
ctf_free (buf); free (buf);
return err; 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_dprintf ("zlib deflate err: %s\n", zError (rc));
ctf_set_errno (fp, ECTF_COMPRESS); ctf_set_errno (fp, ECTF_COMPRESS);
ctf_free (buf); free (buf);
return NULL; return NULL;
} }
*size += compress_len; *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) for (cdp = ctf_list_next (&cd->cd_nodes[i]); cdp != NULL; cdp = ndp)
{ {
ndp = ctf_list_next (cdp); 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; 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; cd->cd_err = EAGAIN;
return; return;
@ -176,10 +176,14 @@ void ctf_decl_sprintf (ctf_decl_t *cd, const char *format, ...)
va_end (ap); va_end (ap);
if (n > 0) 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. */ /* Sticky error condition. */
if (n < 0) if (n < 0 || cd->cd_buf == NULL)
{ {
free (cd->cd_buf); free (cd->cd_buf);
cd->cd_buf = NULL; 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; 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)); return (ctf_set_errno (state->cds_fp, ENOMEM));
cdi->cdi_item = str; cdi->cdi_item = str;
@ -73,7 +73,7 @@ ctf_dump_free (ctf_dump_state_t *state)
{ {
free (cdi->cdi_item); free (cdi->cdi_item);
next_cdi = ctf_list_next (cdi); 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 by bit. The first call will take (much) longer than otherwise, but the
amortized time needed is the same. */ 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); ctf_set_errno (fp, ENOMEM);
goto end; goto end;
@ -779,7 +779,7 @@ ctf_dump (ctf_file_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
end: end:
ctf_dump_free (state); ctf_dump_free (state);
ctf_free (state); free (state);
ctf_set_errno (fp, 0); ctf_set_errno (fp, 0);
*statep = NULL; *statep = NULL;
return 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 void ctf_munmap (void *, size_t);
extern ssize_t ctf_pread (int fd, void *buf, ssize_t count, off_t offset); 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); 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 char *ctf_str_append (char *, const char *);
extern const char *ctf_strerror (int); 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 number unchanged, so that LCTF_INFO_* still works on the
as-yet-untranslated type info. */ 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; return ECTF_ZALLOC;
/* Start at ctf_buf, not ctf_base, to squeeze out the original header: we /* 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); assert ((size_t) t2p - (size_t) fp->ctf_buf == cth->cth_stroff);
ctf_set_version (fp, cth, CTF_VERSION_1_UPGRADED_3); ctf_set_version (fp, cth, CTF_VERSION_1_UPGRADED_3);
ctf_free (old_ctf_base); free (old_ctf_base);
return 0; return 0;
} }
@ -746,9 +746,9 @@ init_types (ctf_file_t *fp, ctf_header_t *cth)
ctf_hash_eq_string)) == NULL) ctf_hash_eq_string)) == NULL)
return ENOMEM; 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_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) if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
return ENOMEM; /* Memory allocation failed. */ 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) if (ctfsect->cts_size < hdrsz)
return (ctf_set_open_errno (errp, ECTF_NOCTFBUF)); 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)); return (ctf_set_open_errno (errp, ENOMEM));
memset (fp, 0, sizeof (ctf_file_t)); 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) if (writable)
fp->ctf_flags |= LCTF_RDWR; 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)); return (ctf_set_open_errno (errp, ENOMEM));
} }
hp = fp->ctf_header; 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 /* We are allocating this ourselves, so we can drop the ctf header
copy in favour of ctf->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; err = ECTF_ZALLOC;
goto bad; goto bad;
@ -1466,7 +1466,7 @@ ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect,
} }
else if (foreign_endian) 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; err = ECTF_ZALLOC;
goto bad; 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) 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) 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) 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) if (fp->ctf_data.cts_name == NULL)
fp->ctf_data.cts_name = _CTF_NULLSTR; 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) if (symsect != NULL)
{ {
fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize; 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) if (fp->ctf_sxlate == NULL)
{ {
@ -1613,8 +1625,8 @@ ctf_file_close (ctf_file_t *fp)
return; return;
} }
ctf_free (fp->ctf_dyncuname); free (fp->ctf_dyncuname);
ctf_free (fp->ctf_dynparname); free (fp->ctf_dynparname);
ctf_file_close (fp->ctf_parent); ctf_file_close (fp->ctf_parent);
for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd) 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_dynhash_destroy (fp->ctf_dvhash);
ctf_str_free_atoms (fp); ctf_str_free_atoms (fp);
ctf_free (fp->ctf_tmp_typeslice); free (fp->ctf_tmp_typeslice);
if (fp->ctf_data.cts_name != _CTF_NULLSTR) 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) 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) 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) else if (fp->ctf_data_mmapped)
ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len); 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_syn_ext_strtab);
ctf_dynhash_destroy (fp->ctf_link_inputs); 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_link_cu_mapping);
ctf_dynhash_destroy (fp->ctf_add_processing); ctf_dynhash_destroy (fp->ctf_add_processing);
ctf_free (fp->ctf_sxlate); free (fp->ctf_sxlate);
ctf_free (fp->ctf_txlate); free (fp->ctf_txlate);
ctf_free (fp->ctf_ptrtab); free (fp->ctf_ptrtab);
ctf_free (fp->ctf_header); free (fp->ctf_header);
ctf_free (fp); free (fp);
} }
/* The converse of ctf_open(). ctf_open() disguises whatever it opens as an /* 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 /* Set the parent name. It is an error to call this routine without calling
ctf_import() at some point. */ ctf_import() at some point. */
void int
ctf_parent_name_set (ctf_file_t *fp, const char *name) ctf_parent_name_set (ctf_file_t *fp, const char *name)
{ {
if (fp->ctf_dynparname != NULL) 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; fp->ctf_parname = fp->ctf_dynparname;
return 0;
} }
/* Return the name of the compilation unit this CTF file applies to. Usually /* 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. */ /* Set the compilation unit name. */
void int
ctf_cuname_set (ctf_file_t *fp, const char *name) ctf_cuname_set (ctf_file_t *fp, const char *name)
{ {
if (fp->ctf_dyncuname != NULL) 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; fp->ctf_cuname = fp->ctf_dyncuname;
return 0;
} }
/* Import the types from the specified parent container by storing a pointer /* 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)); return (ctf_set_errno (fp, ECTF_DMODEL));
if (fp->ctf_parent != NULL) if (fp->ctf_parent != NULL)
ctf_file_close (fp->ctf_parent); {
ctf_file_close (fp->ctf_parent);
fp->ctf_parent = NULL;
}
if (pfp != NULL) if (pfp != NULL)
{ {
fp->ctf_flags |= LCTF_CHILD; int err;
pfp->ctf_refcnt++;
if (fp->ctf_parname == NULL) 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; fp->ctf_parent = pfp;
return 0; 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); next = ctf_list_next (ref);
ctf_list_delete (&atom->csa_refs, 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_atom_t *atom = a;
ctf_str_purge_atom_refs (atom); 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 /* 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) ctf_str_create_atoms (ctf_file_t *fp)
{ {
fp->ctf_str_atoms = ctf_dynhash_create (ctf_hash_string, ctf_hash_eq_string, 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) if (fp->ctf_str_atoms == NULL)
return -ENOMEM; return -ENOMEM;
@ -154,7 +154,7 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
if (add_ref) 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; return NULL;
aref->caf_ref = ref; aref->caf_ref = ref;
} }
@ -169,11 +169,11 @@ ctf_str_add_ref_internal (ctf_file_t *fp, const char *str,
return atom; return atom;
} }
if ((atom = ctf_alloc (sizeof (struct ctf_str_atom))) == NULL) if ((atom = malloc (sizeof (struct ctf_str_atom))) == NULL)
goto oom; goto oom;
memset (atom, 0, sizeof (struct ctf_str_atom)); memset (atom, 0, sizeof (struct ctf_str_atom));
if ((newstr = ctf_strdup (str)) == NULL) if ((newstr = strdup (str)) == NULL)
goto oom; goto oom;
if (ctf_dynhash_insert (fp->ctf_str_atoms, newstr, atom) < 0) 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: oom:
if (newstr) if (newstr)
ctf_dynhash_remove (fp->ctf_str_atoms, newstr); ctf_dynhash_remove (fp->ctf_str_atoms, newstr);
ctf_free (atom); free (atom);
ctf_free (aref); free (aref);
ctf_free (newstr); free (newstr);
return NULL; 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) if (aref->caf_ref == ref)
{ {
ctf_list_delete (&atom->csa_refs, aref); 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 *), qsort (&sorttab[1], s.strtab_count - 1, sizeof (ctf_str_atom_t *),
ctf_str_sort_strtab); 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; goto oom_sorttab;
if (!fp->ctf_syn_ext_strtab) 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 #endif
} }
_libctf_malloc_ void *
ctf_alloc (size_t size)
{
return (malloc (size));
}
void
ctf_free (void *buf)
{
free (buf);
}
ssize_t ssize_t
ctf_pread (int fd, void *buf, ssize_t count, off_t offset) 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; 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. */ /* A string appender working on dynamic strings. */
char * char *