diff options
| -rw-r--r-- | include/ChangeLog | 5 | ||||
| -rw-r--r-- | include/ctf-api.h | 4 | ||||
| -rw-r--r-- | libctf/ChangeLog | 43 | ||||
| -rw-r--r-- | libctf/ctf-create.c | 65 | ||||
| -rw-r--r-- | libctf/ctf-decl.c | 12 | ||||
| -rw-r--r-- | libctf/ctf-dump.c | 8 | ||||
| -rw-r--r-- | libctf/ctf-impl.h | 6 | ||||
| -rw-r--r-- | libctf/ctf-open.c | 92 | ||||
| -rw-r--r-- | libctf/ctf-string.c | 22 | ||||
| -rw-r--r-- | libctf/ctf-subr.c | 12 | ||||
| -rw-r--r-- | libctf/ctf-util.c | 13 |
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 * |