@@ -225,10 +225,7 @@ ctf_dtd_insert (ctf_dict_t *fp, ctf_dtdef_t *dtd, int flag, int kind)
const char *name;
if (ctf_dynhash_insert (fp->ctf_dthash, (void *) (uintptr_t) dtd->dtd_type,
dtd) < 0)
- {
- ctf_set_errno (fp, ENOMEM);
- return -1;
- }
+ return ctf_set_errno (fp, ENOMEM);
if (flag == CTF_ADD_ROOT && dtd->dtd_data.ctt_name
&& (name = ctf_strraw (fp, dtd->dtd_data.ctt_name)) != NULL)
@@ -239,8 +236,7 @@ ctf_dtd_insert (ctf_dict_t *fp, ctf_dtdef_t *dtd, int flag, int kind)
{
ctf_dynhash_remove (fp->ctf_dthash, (void *) (uintptr_t)
dtd->dtd_type);
- ctf_set_errno (fp, ENOMEM);
- return -1;
+ return ctf_set_errno (fp, ENOMEM);
}
}
ctf_list_append (&fp->ctf_dtdefs, dtd);
@@ -329,10 +325,7 @@ int
ctf_dvd_insert (ctf_dict_t *fp, ctf_dvdef_t *dvd)
{
if (ctf_dynhash_insert (fp->ctf_dvhash, dvd->dvd_name, dvd) < 0)
- {
- ctf_set_errno (fp, ENOMEM);
- return -1;
- }
+ return ctf_set_errno (fp, ENOMEM);
ctf_list_append (&fp->ctf_dvdefs, dvd);
return 0;
}
@@ -453,23 +446,23 @@ ctf_add_generic (ctf_dict_t *fp, uint32_t flag, const char *name, int kind,
ctf_id_t type;
if (flag != CTF_ADD_NONROOT && flag != CTF_ADD_ROOT)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
if (!(fp->ctf_flags & LCTF_RDWR))
- return (ctf_set_errno (fp, ECTF_RDONLY));
+ return (ctf_set_typed_errno (fp, ECTF_RDONLY));
if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) >= CTF_MAX_TYPE)
- return (ctf_set_errno (fp, ECTF_FULL));
+ return (ctf_set_typed_errno (fp, ECTF_FULL));
if (LCTF_INDEX_TO_TYPE (fp, fp->ctf_typemax, 1) == (CTF_MAX_PTYPE - 1))
- return (ctf_set_errno (fp, ECTF_FULL));
+ return (ctf_set_typed_errno (fp, ECTF_FULL));
/* Make sure ptrtab always grows to be big enough for all types. */
if (ctf_grow_ptrtab (fp) < 0)
return CTF_ERR; /* errno is set for us. */
if ((dtd = calloc (1, sizeof (ctf_dtdef_t))) == NULL)
- return (ctf_set_errno (fp, EAGAIN));
+ return (ctf_set_typed_errno (fp, EAGAIN));
dtd->dtd_vlen_alloc = vlen;
if (vlen > 0)
@@ -499,7 +492,7 @@ ctf_add_generic (ctf_dict_t *fp, uint32_t flag, const char *name, int kind,
return type;
oom:
- ctf_set_errno (fp, EAGAIN);
+ ctf_set_typed_errno (fp, EAGAIN);
err:
free (dtd->dtd_vlen);
free (dtd);
@@ -532,13 +525,13 @@ ctf_add_encoded (ctf_dict_t *fp, uint32_t flag,
uint32_t encoding;
if (ep == NULL)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
if (name == NULL || name[0] == '\0')
- return (ctf_set_errno (fp, ECTF_NONAME));
+ return (ctf_set_typed_errno (fp, ECTF_NONAME));
if (!ctf_assert (fp, kind == CTF_K_INTEGER || kind == CTF_K_FLOAT))
- return -1; /* errno is set for us. */
+ return CTF_ERR; /* errno is set for us. */
if ((type = ctf_add_generic (fp, flag, name, kind, sizeof (uint32_t),
&dtd)) == CTF_ERR)
@@ -570,7 +563,7 @@ ctf_add_reftype (ctf_dict_t *fp, uint32_t flag, ctf_id_t ref, uint32_t kind)
int child = fp->ctf_flags & LCTF_CHILD;
if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
return CTF_ERR; /* errno is set for us. */
@@ -613,13 +606,13 @@ ctf_add_slice (ctf_dict_t *fp, uint32_t flag, ctf_id_t ref,
ctf_dict_t *tmp = fp;
if (ep == NULL)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
if ((ep->cte_bits > 255) || (ep->cte_offset > 255))
- return (ctf_set_errno (fp, ECTF_SLICEOVERFLOW));
+ return (ctf_set_typed_errno (fp, ECTF_SLICEOVERFLOW));
if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
if (ref != 0 && ((tp = ctf_lookup_by_id (&tmp, ref)) == NULL))
return CTF_ERR; /* errno is set for us. */
@@ -634,7 +627,7 @@ ctf_add_slice (ctf_dict_t *fp, uint32_t flag, ctf_id_t ref,
if ((kind != CTF_K_INTEGER) && (kind != CTF_K_FLOAT) &&
(kind != CTF_K_ENUM)
&& (ref != 0))
- return (ctf_set_errno (fp, ECTF_NOTINTFP));
+ return (ctf_set_typed_errno (fp, ECTF_NOTINTFP));
if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_SLICE,
sizeof (ctf_slice_t), &dtd)) == CTF_ERR)
@@ -682,7 +675,7 @@ ctf_add_array (ctf_dict_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
ctf_dict_t *tmp = fp;
if (arp == NULL)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
if (arp->ctr_contents != 0
&& ctf_lookup_by_id (&tmp, arp->ctr_contents) == NULL)
@@ -697,7 +690,7 @@ ctf_add_array (ctf_dict_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
ctf_err_warn (fp, 1, ECTF_INCOMPLETE,
_("ctf_add_array: index type %lx is incomplete"),
arp->ctr_contents);
- return (ctf_set_errno (fp, ECTF_INCOMPLETE));
+ return (ctf_set_typed_errno (fp, ECTF_INCOMPLETE));
}
if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY,
@@ -751,11 +744,11 @@ ctf_add_function (ctf_dict_t *fp, uint32_t flag,
size_t i;
if (!(fp->ctf_flags & LCTF_RDWR))
- return (ctf_set_errno (fp, ECTF_RDONLY));
+ return (ctf_set_typed_errno (fp, ECTF_RDONLY));
if (ctc == NULL || (ctc->ctc_flags & ~CTF_FUNC_VARARG) != 0
|| (ctc->ctc_argc != 0 && argv == NULL))
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
vlen = ctc->ctc_argc;
if (ctc->ctc_flags & CTF_FUNC_VARARG)
@@ -766,7 +759,7 @@ ctf_add_function (ctf_dict_t *fp, uint32_t flag,
return CTF_ERR; /* errno is set for us. */
if (vlen > CTF_MAX_VLEN)
- return (ctf_set_errno (fp, EOVERFLOW));
+ return (ctf_set_typed_errno (fp, EOVERFLOW));
/* One word extra allocated for padding for 4-byte alignment if need be.
Not reflected in vlen: we don't want to copy anything into it, and
@@ -818,7 +811,7 @@ ctf_add_struct_sized (ctf_dict_t *fp, uint32_t flag, const char *name,
if (dtd->dtd_vlen_alloc == 0)
{
if ((dtd->dtd_vlen = calloc (1, initial_vlen)) == NULL)
- return (ctf_set_errno (fp, ENOMEM));
+ return (ctf_set_typed_errno (fp, ENOMEM));
dtd->dtd_vlen_alloc = initial_vlen;
}
@@ -858,7 +851,7 @@ ctf_add_union_sized (ctf_dict_t *fp, uint32_t flag, const char *name,
if (dtd->dtd_vlen_alloc == 0)
{
if ((dtd->dtd_vlen = calloc (1, initial_vlen)) == NULL)
- return (ctf_set_errno (fp, ENOMEM));
+ return (ctf_set_typed_errno (fp, ENOMEM));
dtd->dtd_vlen_alloc = initial_vlen;
}
@@ -897,7 +890,7 @@ ctf_add_enum (ctf_dict_t *fp, uint32_t flag, const char *name)
if (dtd->dtd_vlen_alloc == 0)
{
if ((dtd->dtd_vlen = calloc (1, initial_vlen)) == NULL)
- return (ctf_set_errno (fp, ENOMEM));
+ return (ctf_set_typed_errno (fp, ENOMEM));
dtd->dtd_vlen_alloc = initial_vlen;
}
@@ -925,7 +918,7 @@ ctf_add_enum_encoded (ctf_dict_t *fp, uint32_t flag, const char *name,
{
if ((ctf_type_kind (fp, type) != CTF_K_FORWARD) &&
(ctf_type_kind_unsliced (fp, type) != CTF_K_ENUM))
- return (ctf_set_errno (fp, ECTF_NOTINTFP));
+ return (ctf_set_typed_errno (fp, ECTF_NOTINTFP));
}
else if ((type = ctf_add_enum (fp, flag, name)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
@@ -943,10 +936,10 @@ ctf_add_forward (ctf_dict_t *fp, uint32_t flag, const char *name,
ctf_id_t type = 0;
if (!ctf_forwardable_kind (kind))
- return (ctf_set_errno (fp, ECTF_NOTSUE));
+ return (ctf_set_typed_errno (fp, ECTF_NOTSUE));
if (name == NULL || name[0] == '\0')
- return (ctf_set_errno (fp, ECTF_NONAME));
+ return (ctf_set_typed_errno (fp, ECTF_NONAME));
/* If the type is already defined or exists as a forward tag, just
return the ctf_id_t of the existing definition. */
@@ -985,7 +978,7 @@ ctf_add_unknown (ctf_dict_t *fp, uint32_t flag, const char *name)
_("ctf_add_unknown: cannot add unknown type "
"named %s: type of this name already defined"),
name ? name : _("(unnamed type)"));
- return (ctf_set_errno (fp, ECTF_CONFLICT));
+ return (ctf_set_typed_errno (fp, ECTF_CONFLICT));
}
}
@@ -1007,10 +1000,10 @@ ctf_add_typedef (ctf_dict_t *fp, uint32_t flag, const char *name,
ctf_dict_t *tmp = fp;
if (ref == CTF_ERR || ref > CTF_MAX_TYPE)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
if (name == NULL || name[0] == '\0')
- return (ctf_set_errno (fp, ECTF_NONAME));
+ return (ctf_set_typed_errno (fp, ECTF_NONAME));
if (ref != 0 && ctf_lookup_by_id (&tmp, ref) == NULL)
return CTF_ERR; /* errno is set for us. */
@@ -1575,14 +1568,14 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
ctf_id_t orig_src_type = src_type;
if (!(dst_fp->ctf_flags & LCTF_RDWR))
- return (ctf_set_errno (dst_fp, ECTF_RDONLY));
+ return (ctf_set_typed_errno (dst_fp, ECTF_RDONLY));
if ((src_tp = ctf_lookup_by_id (&src_fp, src_type)) == NULL)
- return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
+ return (ctf_set_typed_errno (dst_fp, ctf_errno (src_fp)));
if ((ctf_type_resolve (src_fp, src_type) == CTF_ERR)
&& (ctf_errno (src_fp) == ECTF_NONREPRESENTABLE))
- return (ctf_set_errno (dst_fp, ECTF_NONREPRESENTABLE));
+ return (ctf_set_typed_errno (dst_fp, ECTF_NONREPRESENTABLE));
name = ctf_strptr (src_fp, src_tp->ctt_name);
kind = LCTF_INFO_KIND (src_fp, src_tp->ctt_info);
@@ -1661,7 +1654,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
_("ctf_add_type: conflict for type %s: "
"kinds differ, new: %i; old (ID %lx): %i"),
name, kind, dst_type, dst_kind);
- return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
+ return (ctf_set_typed_errno (dst_fp, ECTF_CONFLICT));
}
}
@@ -1672,7 +1665,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
if (kind == CTF_K_INTEGER || kind == CTF_K_FLOAT || kind == CTF_K_SLICE)
{
if (ctf_type_encoding (src_fp, src_type, &src_en) != 0)
- return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
+ return (ctf_set_typed_errno (dst_fp, ctf_errno (src_fp)));
if (dst_type != CTF_ERR)
{
@@ -1702,7 +1695,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
}
else
{
- return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
+ return (ctf_set_typed_errno (dst_fp, ECTF_CONFLICT));
}
}
else
@@ -1740,7 +1733,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
if (ctf_dynhash_insert (proc_tracking_fp->ctf_add_processing,
(void *) (uintptr_t) src_type, (void *) 1) < 0)
- return ctf_set_errno (dst_fp, ENOMEM);
+ return ctf_set_typed_errno (dst_fp, ENOMEM);
switch (kind)
{
@@ -1785,7 +1778,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
case CTF_K_ARRAY:
if (ctf_array_info (src_fp, src_type, &src_ar) != 0)
- return (ctf_set_errno (dst_fp, ctf_errno (src_fp)));
+ return (ctf_set_typed_errno (dst_fp, ctf_errno (src_fp)));
src_ar.ctr_contents =
ctf_add_type_internal (dst_fp, src_fp, src_ar.ctr_contents,
@@ -1812,7 +1805,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
src_ar.ctr_index, src_ar.ctr_nelems,
dst_ar.ctr_contents, dst_ar.ctr_index,
dst_ar.ctr_nelems);
- return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
+ return (ctf_set_typed_errno (dst_fp, ECTF_CONFLICT));
}
}
else
@@ -1859,7 +1852,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
"size differs, old %li, new %li"), name,
dst_type, (long) ctf_type_size (src_fp, src_type),
(long) ctf_type_size (dst_fp, dst_type));
- return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
+ return (ctf_set_typed_errno (dst_fp, ECTF_CONFLICT));
}
if (ctf_member_iter (src_fp, src_type, membcmp, &dst))
@@ -1867,7 +1860,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
ctf_err_warn (dst_fp, 1, ECTF_CONFLICT,
_("conflict for type %s against ID %lx: members "
"differ, see above"), name, dst_type);
- return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
+ return (ctf_set_typed_errno (dst_fp, ECTF_CONFLICT));
}
break;
@@ -1925,7 +1918,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
ctf_err_warn (dst_fp, 1, ECTF_CONFLICT,
_("conflict for enum %s against ID %lx: members "
"differ, see above"), name, dst_type);
- return (ctf_set_errno (dst_fp, ECTF_CONFLICT));
+ return (ctf_set_typed_errno (dst_fp, ECTF_CONFLICT));
}
}
else
@@ -1964,7 +1957,7 @@ ctf_add_type_internal (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type
break;
default:
- return (ctf_set_errno (dst_fp, ECTF_CORRUPT));
+ return (ctf_set_typed_errno (dst_fp, ECTF_CORRUPT));
}
if (dst_type != CTF_ERR)
@@ -1985,7 +1978,7 @@ ctf_add_type (ctf_dict_t *dst_fp, ctf_dict_t *src_fp, ctf_id_t src_type)
/* We store the hash on the source, because it contains only source type IDs:
but callers will invariably expect errors to appear on the dest. */
if (!src_fp->ctf_add_processing)
- return (ctf_set_errno (dst_fp, ENOMEM));
+ return (ctf_set_typed_errno (dst_fp, ENOMEM));
id = ctf_add_type_internal (dst_fp, src_fp, src_type, src_fp);
ctf_dynhash_empty (src_fp->ctf_add_processing);
@@ -321,7 +321,7 @@ id_to_packed_id (ctf_dict_t *fp, int input_num, ctf_id_t type)
oom:
free (dynkey);
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return NULL;
}
@@ -398,7 +398,7 @@ intern (ctf_dict_t *fp, char *atom)
{
if (ctf_dynset_insert (fp->ctf_dedup_atoms, atom) < 0)
{
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return NULL;
}
foo = atom;
@@ -461,7 +461,7 @@ ctf_decorate_type_name (ctf_dict_t *fp, const char *name, int kind)
return ret;
oom:
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return NULL;
}
@@ -981,7 +981,7 @@ ctf_dedup_rhash_type (ctf_dict_t *fp, ctf_dict_t *input, ctf_dict_t **inputs,
input_num, gettext (whaterr), type, kind);
return NULL;
oom:
- ctf_set_errno (fp, errno);
+ ctf_set_typed_errno (fp, errno);
ctf_err_warn (fp, 0, 0, _("%s (%i): %s: during type hashing for type %lx, "
"kind %i"), ctf_link_input_name (input),
input_num, gettext (whaterr), type, kind);
@@ -1051,7 +1051,7 @@ ctf_dedup_hash_type (ctf_dict_t *fp, ctf_dict_t *input,
if ((tp = ctf_lookup_by_id (&input, type)) == NULL)
{
- ctf_set_errno (fp, ctf_errno (input));
+ ctf_set_typed_errno (fp, ctf_errno (input));
ctf_err_warn (fp, 0, 0, _("%s (%i): lookup failure for type %lx: "
"flags %x"), ctf_link_input_name (input),
input_num, type, flags);
@@ -1140,7 +1140,7 @@ ctf_dedup_hash_type (ctf_dict_t *fp, ctf_dict_t *input,
return hval;
oom:
- ctf_set_errno (fp, errno);
+ ctf_set_typed_errno (fp, errno);
err:
ctf_err_warn (fp, 0, 0, _("%s (%i): %s: during type hashing, "
"type %lx, kind %i"),
@@ -1318,8 +1318,7 @@ ctf_dedup_mark_conflicting_hash (ctf_dict_t *fp, const char *hval)
if (ctf_dynset_cinsert (d->cd_conflicting_types, hval) < 0)
{
ctf_dprintf ("Out of memory marking %s as conflicted\n", hval);
- ctf_set_errno (fp, errno);
- return -1;
+ return ctf_set_errno (fp, errno);
}
/* If any types cite this type, mark them conflicted too. */
@@ -2452,7 +2451,7 @@ ctf_dedup_maybe_synthesize_forward (ctf_dict_t *output, ctf_dict_t *target,
if ((emitted_forward = ctf_add_forward (target, CTF_ADD_ROOT, name,
fwdkind)) == CTF_ERR)
{
- ctf_set_errno (output, ctf_errno (target));
+ ctf_set_typed_errno (output, ctf_errno (target));
return CTF_ERR;
}
@@ -2460,7 +2459,7 @@ ctf_dedup_maybe_synthesize_forward (ctf_dict_t *output, ctf_dict_t *target,
decorated, (void *) (uintptr_t)
emitted_forward) < 0)
{
- ctf_set_errno (output, ENOMEM);
+ ctf_set_typed_errno (output, ENOMEM);
return CTF_ERR;
}
}
@@ -2525,7 +2524,7 @@ ctf_dedup_id_to_target (ctf_dict_t *output, ctf_dict_t *target,
if ((input->ctf_flags & LCTF_CHILD) && (LCTF_TYPE_ISPARENT (input, id)))
{
if (!ctf_assert (output, parents[input_num] <= ninputs))
- return -1;
+ return CTF_ERR;
input = inputs[parents[input_num]];
input_num = parents[input_num];
}
@@ -2534,7 +2533,7 @@ ctf_dedup_id_to_target (ctf_dict_t *output, ctf_dict_t *target,
CTF_DEDUP_GID (output, input_num, id));
if (!ctf_assert (output, hval && td->cd_output_emission_hashes))
- return -1;
+ return CTF_ERR;
/* If this type is a conflicted tagged structure, union, or forward,
substitute a synthetic forward instead, emitting it if need be. Only do
@@ -2550,10 +2549,10 @@ ctf_dedup_id_to_target (ctf_dict_t *output, ctf_dict_t *target,
case 0: /* No forward needed. */
break;
case -1:
- ctf_set_errno (err_fp, ctf_errno (output));
+ ctf_set_typed_errno (err_fp, ctf_errno (output));
ctf_err_warn (err_fp, 0, 0, _("cannot add synthetic forward for type "
"%i/%lx"), input_num, id);
- return -1;
+ return CTF_ERR;
default:
return emitted_forward;
}
@@ -2568,7 +2567,7 @@ ctf_dedup_id_to_target (ctf_dict_t *output, ctf_dict_t *target,
ctf_dprintf ("Checking shared parent for target\n");
if (!ctf_assert (output, (target != output)
&& (target->ctf_flags & LCTF_CHILD)))
- return -1;
+ return CTF_ERR;
target_id = ctf_dynhash_lookup (od->cd_output_emission_hashes, hval);
@@ -2582,13 +2581,13 @@ ctf_dedup_id_to_target (ctf_dict_t *output, ctf_dict_t *target,
ctf_err_warn (err_fp, 0, ctf_errno (output),
_("cannot add synthetic forward for type %i/%lx"),
input_num, id);
- return ctf_set_errno (err_fp, ctf_errno (output));
+ return ctf_set_typed_errno (err_fp, ctf_errno (output));
default:
return emitted_forward;
}
}
if (!ctf_assert (output, target_id))
- return -1;
+ return CTF_ERR;
return (ctf_id_t) (uintptr_t) target_id;
}
@@ -3101,7 +3100,7 @@ ctf_dedup_emit (ctf_dict_t *output, ctf_dict_t **inputs, uint32_t ninputs,
{
ctf_err_warn (output, 0, ENOMEM,
_("out of memory allocating link outputs array"));
- ctf_set_errno (output, ENOMEM);
+ ctf_set_typed_errno (output, ENOMEM);
return NULL;
}
*noutputs = num_outputs;
@@ -3152,7 +3151,7 @@ ctf_dedup_type_mapping (ctf_dict_t *fp, ctf_dict_t *src_fp, ctf_id_t src_type)
output = fp->ctf_parent;
else
{
- ctf_set_errno (fp, ECTF_INTERNAL);
+ ctf_set_typed_errno (fp, ECTF_INTERNAL);
ctf_err_warn (fp, 0, ECTF_INTERNAL,
_("dict %p passed to ctf_dedup_type_mapping is not a "
"deduplicated output"), (void *) fp);
@@ -93,7 +93,7 @@ ctf_dump_format_type (ctf_dict_t *fp, ctf_id_t id, int flag)
ctf_id_t new_id;
char *str = NULL, *bit = NULL, *buf = NULL;
- ctf_set_errno (fp, 0);
+ ctf_set_typed_errno (fp, 0);
new_id = id;
do
{
@@ -117,7 +117,7 @@ ctf_dump_format_type (ctf_dict_t *fp, ctf_id_t id, int flag)
{
if (id == 0 || ctf_errno (fp) == ECTF_NONREPRESENTABLE)
{
- ctf_set_errno (fp, ECTF_NONREPRESENTABLE);
+ ctf_set_typed_errno (fp, ECTF_NONREPRESENTABLE);
str = str_append (str, " (type not represented in CTF)");
return str;
}
@@ -237,7 +237,7 @@ ctf_dump_format_type (ctf_dict_t *fp, ctf_id_t id, int flag)
return str;
oom:
- ctf_set_errno (fp, errno);
+ ctf_set_typed_errno (fp, errno);
err:
ctf_err_warn (fp, 1, 0, _("cannot format name dumping type 0x%lx"), id);
free (buf);
@@ -707,7 +707,7 @@ ctf_dump (ctf_dict_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
if ((*statep = malloc (sizeof (struct ctf_dump_state))) == NULL)
{
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
goto end;
}
state = *statep;
@@ -726,7 +726,7 @@ ctf_dump (ctf_dict_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
{
if (ctf_errno (fp) != ECTF_NOLABELDATA)
goto end; /* errno is set for us. */
- ctf_set_errno (fp, 0);
+ ctf_set_typed_errno (fp, 0);
}
break;
case CTF_SECT_OBJT:
@@ -749,7 +749,7 @@ ctf_dump (ctf_dict_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
ctf_dump_str (fp, state);
break;
default:
- ctf_set_errno (fp, ECTF_DUMPSECTUNKNOWN);
+ ctf_set_typed_errno (fp, ECTF_DUMPSECTUNKNOWN);
goto end;
}
}
@@ -759,7 +759,7 @@ ctf_dump (ctf_dict_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
if (state->cds_sect != sect)
{
- ctf_set_errno (fp, ECTF_DUMPSECTCHANGED);
+ ctf_set_typed_errno (fp, ECTF_DUMPSECTCHANGED);
goto end;
}
}
@@ -813,18 +813,18 @@ ctf_dump (ctf_dict_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
str = strdup (state->cds_current->cdi_item);
if (!str)
{
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return str;
}
}
- ctf_set_errno (fp, 0);
+ ctf_set_typed_errno (fp, 0);
return str;
end:
ctf_dump_free (state);
free (state);
- ctf_set_errno (fp, 0);
+ ctf_set_typed_errno (fp, 0);
*statep = NULL;
return NULL;
}
@@ -741,7 +741,6 @@ extern struct ctf_archive *ctf_arc_open_internal (const char *, int *);
extern void ctf_arc_close_internal (struct ctf_archive *);
extern const ctf_preamble_t *ctf_arc_bufpreamble (const ctf_sect_t *);
extern void *ctf_set_open_errno (int *, int);
-extern unsigned long ctf_set_errno (ctf_dict_t *, int);
extern void ctf_flip_header (ctf_header_t *);
extern int ctf_flip (ctf_dict_t *, ctf_header_t *, unsigned char *, int);
@@ -90,6 +90,23 @@ ctf_assert_internal (ctf_dict_t *fp, const char *file, size_t line,
return expr;
}
+static inline int
+ctf_set_errno (ctf_dict_t *fp, int err)
+{
+ fp->ctf_errno = err;
+ /* Don't rely on CTF_ERR here as it will not properly sign extend on 64-bit
+ Windows ABI. */
+ return -1;
+}
+
+static inline ctf_id_t
+ctf_set_typed_errno (ctf_dict_t *fp, int err)
+{
+ fp->ctf_errno = err;
+ return CTF_ERR;
+}
+
+
#ifdef __cplusplus
}
#endif
@@ -48,12 +48,12 @@ ctf_label_topmost (ctf_dict_t *fp)
if (num_labels == 0)
{
- (void) ctf_set_errno (fp, ECTF_NOLABELDATA);
+ (void) ctf_set_typed_errno (fp, ECTF_NOLABELDATA);
return NULL;
}
if ((s = ctf_strraw (fp, (ctlp + num_labels - 1)->ctl_label)) == NULL)
- (void) ctf_set_errno (fp, ECTF_CORRUPT);
+ (void) ctf_set_typed_errno (fp, ECTF_CORRUPT);
return s;
}
@@ -243,8 +243,7 @@ ctf_link_lazy_open (ctf_dict_t *fp, ctf_link_input_t *input)
#else
ctf_err_warn (fp, 0, ECTF_NEEDSBFD, _("cannot open %s lazily"),
input->clin_filename);
- ctf_set_errno (fp, ECTF_NEEDSBFD);
- return -1;
+ return ctf_set_errno (fp, ECTF_NEEDSBFD);
#endif
/* Having no CTF sections is not an error. We just don't need to do
@@ -257,8 +256,7 @@ ctf_link_lazy_open (ctf_dict_t *fp, ctf_link_input_t *input)
ctf_err_warn (fp, 0, err, _("opening CTF %s failed"),
input->clin_filename);
- ctf_set_errno (fp, err);
- return -1;
+ return ctf_set_errno (fp, err);
}
if ((count = ctf_archive_count (input->clin_arc)) == 0)
@@ -334,7 +332,7 @@ ctf_create_per_cu (ctf_dict_t *fp, ctf_dict_t *input, const char *cu_name)
{
ctf_err_warn (fp, 0, err, _("cannot create per-CU CTF archive for "
"input CU %s"), cu_name);
- ctf_set_errno (fp, err);
+ ctf_set_typed_errno (fp, err);
return NULL;
}
@@ -357,7 +355,7 @@ ctf_create_per_cu (ctf_dict_t *fp, ctf_dict_t *input, const char *cu_name)
oom:
free (dynname);
ctf_dict_close (cu_fp);
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return NULL;
}
@@ -680,8 +678,7 @@ ctf_link_deduplicating_count_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names,
{
ctf_err_warn (fp, 0, err, _("iteration error counting deduplicating "
"CTF link inputs"));
- ctf_set_errno (fp, err);
- return -1;
+ return ctf_set_errno (fp, err);
}
if (!count)
@@ -783,7 +780,7 @@ ctf_link_deduplicating_open_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names,
if (err != ECTF_NOMEMBNAM)
{
ctf_next_destroy (i);
- ctf_set_errno (fp, err);
+ ctf_set_typed_errno (fp, err);
goto err;
}
}
@@ -835,7 +832,7 @@ ctf_link_deduplicating_open_inputs (ctf_dict_t *fp, ctf_dynhash_t *cu_names,
err = ENOMEM;
iterr:
- ctf_set_errno (fp, err);
+ ctf_set_typed_errno (fp, err);
err:
free (dedup_inputs);
@@ -1355,8 +1352,7 @@ ctf_link_empty_outputs (ctf_dict_t *fp)
{
fp->ctf_flags &= ~LCTF_LINKING;
ctf_err_warn (fp, 1, err, _("iteration error removing old outputs"));
- ctf_set_errno (fp, err);
- return -1;
+ return ctf_set_errno (fp, err);
}
return 0;
}
@@ -1433,7 +1429,7 @@ ctf_link_deduplicating (ctf_dict_t *fp)
continue;
oom_one_output:
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
ctf_err_warn (fp, 0, 0, _("out of memory allocating link outputs"));
free (dynname);
@@ -1465,7 +1461,7 @@ ctf_link_deduplicating (ctf_dict_t *fp)
return; /* errno is set for us. */
ninputs = 0; /* Prevent double-close. */
- ctf_set_errno (fp, 0);
+ ctf_set_typed_errno (fp, 0);
/* Fall through. */
@@ -1536,8 +1532,7 @@ ctf_link (ctf_dict_t *fp, int flags)
{
fp->ctf_flags &= ~LCTF_LINKING;
ctf_err_warn (fp, 1, err, _("iteration error creating empty CUs"));
- ctf_set_errno (fp, err);
- return -1;
+ return ctf_set_errno (fp, err);
}
}
@@ -1785,14 +1780,14 @@ ctf_accumulate_archive_names (void *key, void *value, void *arg_)
if ((names = realloc (arg->names, sizeof (char *) * ++(arg->i))) == NULL)
{
(arg->i)--;
- ctf_set_errno (arg->fp, ENOMEM);
+ ctf_set_typed_errno (arg->fp, ENOMEM);
return;
}
if ((files = realloc (arg->files, sizeof (ctf_dict_t *) * arg->i)) == NULL)
{
(arg->i)--;
- ctf_set_errno (arg->fp, ENOMEM);
+ ctf_set_typed_errno (arg->fp, ENOMEM);
return;
}
@@ -1815,7 +1810,7 @@ ctf_accumulate_archive_names (void *key, void *value, void *arg_)
sizeof (char *) * ++(arg->ndynames))) == NULL)
{
(arg->ndynames)--;
- ctf_set_errno (arg->fp, ENOMEM);
+ ctf_set_typed_errno (arg->fp, ENOMEM);
return;
}
arg->dynames = dynames;
@@ -1986,7 +1981,7 @@ ctf_link_write (ctf_dict_t *fp, size_t *size, size_t threshold)
threshold)) < 0)
{
errloc = "archive writing";
- ctf_set_errno (fp, err);
+ ctf_set_typed_errno (fp, err);
goto err;
}
@@ -2036,7 +2031,7 @@ ctf_link_write (ctf_dict_t *fp, size_t *size, size_t threshold)
return buf;
err_no:
- ctf_set_errno (fp, errno);
+ ctf_set_typed_errno (fp, errno);
/* Turn off the is-linking flag on all the dicts in this link. */
for (i = 0; i < arg.i; i++)
@@ -143,7 +143,7 @@ ctf_lookup_by_name_internal (ctf_dict_t *fp, ctf_dict_t *child,
ctf_id_t ntype, ptype;
if (name == NULL)
- return (ctf_set_errno (fp, EINVAL));
+ return (ctf_set_typed_errno (fp, EINVAL));
for (p = name, end = name + strlen (name); *p != '\0'; p = q)
{
@@ -274,7 +274,7 @@ ctf_lookup_by_name_internal (ctf_dict_t *fp, ctf_dict_t *child,
fp->ctf_tmp_typeslice = xstrndup (p, (size_t) (q - p));
if (fp->ctf_tmp_typeslice == NULL)
{
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return CTF_ERR;
}
}
@@ -292,12 +292,12 @@ ctf_lookup_by_name_internal (ctf_dict_t *fp, ctf_dict_t *child,
}
if (*p != '\0' || type == 0)
- return (ctf_set_errno (fp, ECTF_SYNTAX));
+ return (ctf_set_typed_errno (fp, ECTF_SYNTAX));
return type;
notype:
- ctf_set_errno (fp, ECTF_NOTYPE);
+ ctf_set_typed_errno (fp, ECTF_NOTYPE);
if (fp->ctf_parent != NULL)
{
/* Need to look up in the parent, from the child's perspective.
@@ -306,13 +306,13 @@ ctf_lookup_by_name_internal (ctf_dict_t *fp, ctf_dict_t *child,
if (fp->ctf_pptrtab_typemax < fp->ctf_typemax)
{
if (refresh_pptrtab (fp, fp->ctf_parent) < 0)
- return -1; /* errno is set for us. */
+ return CTF_ERR; /* errno is set for us. */
}
if ((ptype = ctf_lookup_by_name_internal (fp->ctf_parent, fp,
name)) != CTF_ERR)
return ptype;
- return (ctf_set_errno (fp, ctf_errno (fp->ctf_parent)));
+ return (ctf_set_typed_errno (fp, ctf_errno (fp->ctf_parent)));
}
return CTF_ERR;
@@ -336,7 +336,7 @@ ctf_lookup_by_id (ctf_dict_t **fpp, ctf_id_t type)
if ((fp = ctf_get_dict (fp, type)) == NULL)
{
- (void) ctf_set_errno (*fpp, ECTF_NOPARENT);
+ (void) ctf_set_typed_errno (*fpp, ECTF_NOPARENT);
return NULL;
}
@@ -351,7 +351,7 @@ ctf_lookup_by_id (ctf_dict_t **fpp, ctf_id_t type)
*fpp = fp;
return &dtd->dtd_data;
}
- (void) ctf_set_errno (*fpp, ECTF_BADID);
+ (void) ctf_set_typed_errno (*fpp, ECTF_BADID);
return NULL;
}
@@ -364,7 +364,7 @@ ctf_lookup_by_id (ctf_dict_t **fpp, ctf_id_t type)
return (LCTF_INDEX_TO_TYPEPTR (fp, idx));
}
- (void) ctf_set_errno (*fpp, ECTF_BADID);
+ (void) ctf_set_typed_errno (*fpp, ECTF_BADID);
return NULL;
}
@@ -407,10 +407,10 @@ ctf_lookup_variable (ctf_dict_t *fp, const char *name)
if ((ptype = ctf_lookup_variable (fp->ctf_parent, name)) != CTF_ERR)
return ptype;
- return (ctf_set_errno (fp, ctf_errno (fp->ctf_parent)));
+ return (ctf_set_typed_errno (fp, ctf_errno (fp->ctf_parent)));
}
- return (ctf_set_errno (fp, ECTF_NOTYPEDAT));
+ return (ctf_set_typed_errno (fp, ECTF_NOTYPEDAT));
}
return ent->ctv_type;
@@ -447,7 +447,7 @@ ctf_symidx_sort (ctf_dict_t *fp, uint32_t *idx, size_t *nidx,
if ((sorted = malloc (len)) == NULL)
{
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return NULL;
}
@@ -512,7 +512,7 @@ ctf_lookup_symbol_name (ctf_dict_t *fp, unsigned long symidx)
}
break;
default:
- ctf_set_errno (fp, ECTF_SYMTAB);
+ ctf_set_typed_errno (fp, ECTF_SYMTAB);
return _CTF_NULLSTR;
}
@@ -526,12 +526,12 @@ ctf_lookup_symbol_name (ctf_dict_t *fp, unsigned long symidx)
const char *ret;
ret = ctf_lookup_symbol_name (fp->ctf_parent, symidx);
if (ret == NULL)
- ctf_set_errno (fp, ctf_errno (fp->ctf_parent));
+ ctf_set_typed_errno (fp, ctf_errno (fp->ctf_parent));
return ret;
}
else
{
- ctf_set_errno (fp, err);
+ ctf_set_typed_errno (fp, err);
return _CTF_NULLSTR;
}
}
@@ -621,14 +621,14 @@ ctf_lookup_symbol_idx (ctf_dict_t *fp, const char *symname)
}
break;
default:
- ctf_set_errno (fp, ECTF_SYMTAB);
- return (unsigned long) -1;
+ ctf_set_typed_errno (fp, ECTF_SYMTAB);
+ return CTF_ERR;
}
}
/* Searched everything, still not found. */
- return (unsigned long) -1;
+ return CTF_ERR;
try_parent:
if (fp->ctf_parent)
@@ -636,22 +636,22 @@ ctf_lookup_symbol_idx (ctf_dict_t *fp, const char *symname)
unsigned long psym;
if ((psym = ctf_lookup_symbol_idx (fp->ctf_parent, symname))
- != (unsigned long) -1)
+ != CTF_ERR)
return psym;
- ctf_set_errno (fp, ctf_errno (fp->ctf_parent));
- return (unsigned long) -1;
+ ctf_set_typed_errno (fp, ctf_errno (fp->ctf_parent));
+ return CTF_ERR;
}
else
{
- ctf_set_errno (fp, err);
- return (unsigned long) -1;
+ ctf_set_typed_errno (fp, err);
+ return CTF_ERR;
}
oom:
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
ctf_err_warn (fp, 0, ENOMEM, _("cannot allocate memory for symbol "
"lookup hashtab"));
- return (unsigned long) -1;
+ return CTF_ERR;
}
@@ -673,7 +673,7 @@ ctf_symbol_next (ctf_dict_t *fp, ctf_next_t **it, const char **name,
if (!i)
{
if ((i = ctf_next_create ()) == NULL)
- return ctf_set_errno (fp, ENOMEM);
+ return ctf_set_typed_errno (fp, ENOMEM);
i->cu.ctn_fp = fp;
i->ctn_iter_fun = (void (*) (void)) ctf_symbol_next;
@@ -682,10 +682,10 @@ ctf_symbol_next (ctf_dict_t *fp, ctf_next_t **it, const char **name,
}
if ((void (*) (void)) ctf_symbol_next != i->ctn_iter_fun)
- return (ctf_set_errno (fp, ECTF_NEXT_WRONGFUN));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFUN));
if (fp != i->cu.ctn_fp)
- return (ctf_set_errno (fp, ECTF_NEXT_WRONGFP));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFP));
/* We intentionally use raw access, not ctf_lookup_by_symbol, to avoid
incurring additional sorting cost for unsorted symtypetabs coming from the
@@ -701,7 +701,7 @@ ctf_symbol_next (ctf_dict_t *fp, ctf_next_t **it, const char **name,
if (!dynh)
{
ctf_next_destroy (i);
- return (ctf_set_errno (fp, ECTF_NEXT_END));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_END));
}
err = ctf_dynhash_next (dynh, &i->ctn_next, &dyn_name, &dyn_value);
@@ -710,7 +710,7 @@ ctf_symbol_next (ctf_dict_t *fp, ctf_next_t **it, const char **name,
{
ctf_next_destroy (i);
*it = NULL;
- return ctf_set_errno (fp, err);
+ return ctf_set_typed_errno (fp, err);
}
*name = dyn_name;
@@ -786,7 +786,7 @@ ctf_symbol_next (ctf_dict_t *fp, ctf_next_t **it, const char **name,
end:
ctf_next_destroy (i);
*it = NULL;
- return (ctf_set_errno (fp, ECTF_NEXT_END));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_END));
}
/* A bsearch function for function and object index names. */
@@ -821,7 +821,7 @@ ctf_try_lookup_indexed (ctf_dict_t *fp, unsigned long symidx,
"indexed symtypetab\n", symidx, symname);
if (symname[0] == '\0')
- return -1; /* errno is set for us. */
+ return CTF_ERR; /* errno is set for us. */
if (is_function)
{
@@ -835,7 +835,7 @@ ctf_try_lookup_indexed (ctf_dict_t *fp, unsigned long symidx,
== NULL)
{
ctf_err_warn (fp, 0, 0, _("cannot sort function symidx"));
- return -1; /* errno is set for us. */
+ return CTF_ERR; /* errno is set for us. */
}
}
symtypetab = (uint32_t *) (fp->ctf_buf + hp->cth_funcoff);
@@ -855,7 +855,7 @@ ctf_try_lookup_indexed (ctf_dict_t *fp, unsigned long symidx,
== NULL)
{
ctf_err_warn (fp, 0, 0, _("cannot sort object symidx"));
- return -1; /* errno is set for us. */
+ return CTF_ERR; /* errno is set for us. */
}
}
@@ -878,7 +878,7 @@ ctf_try_lookup_indexed (ctf_dict_t *fp, unsigned long symidx,
/* Should be impossible, but be paranoid. */
if ((idx - sxlate) > (ptrdiff_t) nidx)
- return (ctf_set_errno (fp, ECTF_CORRUPT));
+ return (ctf_set_typed_errno (fp, ECTF_CORRUPT));
ctf_dprintf ("Symbol %lx (%s) is of type %x\n", symidx, symname,
symtypetab[*idx]);
@@ -1010,11 +1010,11 @@ ctf_lookup_by_sym_or_name (ctf_dict_t *fp, unsigned long symidx,
ctf_id_t ret = ctf_lookup_by_sym_or_name (fp->ctf_parent, symidx,
symname);
if (ret == CTF_ERR)
- ctf_set_errno (fp, ctf_errno (fp->ctf_parent));
+ ctf_set_typed_errno (fp, ctf_errno (fp->ctf_parent));
return ret;
}
else
- return (ctf_set_errno (fp, err));
+ return (ctf_set_typed_errno (fp, err));
}
/* Given a symbol table index, return the type of the function or data object
@@ -1294,7 +1294,7 @@ ctf_write_mem (ctf_dict_t *fp, size_t *size, size_t threshold)
if ((buf = malloc (compress_len
+ sizeof (struct ctf_header))) == NULL)
{
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
ctf_err_warn (fp, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
(unsigned long) (compress_len + sizeof (struct ctf_header)));
return NULL;
@@ -1317,7 +1317,7 @@ ctf_write_mem (ctf_dict_t *fp, size_t *size, size_t threshold)
{
if ((flipped = malloc (fp->ctf_size)) == NULL)
{
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
ctf_err_warn (fp, 0, 0, _("ctf_write_mem: cannot allocate %li bytes"),
(unsigned long) (fp->ctf_size + sizeof (struct ctf_header)));
return NULL;
@@ -1343,7 +1343,7 @@ ctf_write_mem (ctf_dict_t *fp, size_t *size, size_t threshold)
if ((rc = compress (bp, (uLongf *) &compress_len,
src, fp->ctf_size)) != Z_OK)
{
- ctf_set_errno (fp, ECTF_COMPRESS);
+ ctf_set_typed_errno (fp, ECTF_COMPRESS);
ctf_err_warn (fp, 0, 0, _("zlib deflate err: %s"), zError (rc));
free (buf);
return NULL;
@@ -229,7 +229,7 @@ ctf_str_add_ref_internal (ctf_dict_t *fp, const char *str,
free (atom);
free (aref);
free (newstr);
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return NULL;
}
@@ -288,7 +288,7 @@ ctf_errwarning_next (ctf_dict_t *fp, ctf_next_t **it, int *is_warning,
if (errp)
*errp = ENOMEM;
else if (fp)
- ctf_set_errno (fp, ENOMEM);
+ ctf_set_typed_errno (fp, ENOMEM);
return NULL;
}
@@ -302,7 +302,7 @@ ctf_errwarning_next (ctf_dict_t *fp, ctf_next_t **it, int *is_warning,
if (errp)
*errp = ECTF_NEXT_WRONGFUN;
else if (fp)
- ctf_set_errno (fp, ECTF_NEXT_WRONGFUN);
+ ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFUN);
return NULL;
}
@@ -311,7 +311,7 @@ ctf_errwarning_next (ctf_dict_t *fp, ctf_next_t **it, int *is_warning,
if (errp)
*errp = ECTF_NEXT_WRONGFP;
else if (fp)
- ctf_set_errno (fp, ECTF_NEXT_WRONGFP);
+ ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFP);
return NULL;
}
@@ -324,7 +324,7 @@ ctf_errwarning_next (ctf_dict_t *fp, ctf_next_t **it, int *is_warning,
if (errp)
*errp = ECTF_NEXT_END;
else if (fp)
- ctf_set_errno (fp, ECTF_NEXT_END);
+ ctf_set_typed_errno (fp, ECTF_NEXT_END);
return NULL;
}
@@ -342,5 +342,5 @@ ctf_assert_fail_internal (ctf_dict_t *fp, const char *file, size_t line,
{
ctf_err_warn (fp, 0, ECTF_INTERNAL, _("%s: %lu: libctf assertion failed: %s"),
file, (long unsigned int) line, exprstr);
- ctf_set_errno (fp, ECTF_INTERNAL);
+ ctf_set_typed_errno (fp, ECTF_INTERNAL);
}
@@ -287,7 +287,7 @@ ctf_enum_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
if ((i = ctf_next_create ()) == NULL)
{
- ctf_set_errno (ofp, ENOMEM);
+ ctf_set_typed_errno (ofp, ENOMEM);
return NULL;
}
i->cu.ctn_fp = ofp;
@@ -299,7 +299,7 @@ ctf_enum_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
if (kind != CTF_K_ENUM)
{
ctf_next_destroy (i);
- ctf_set_errno (ofp, ECTF_NOTENUM);
+ ctf_set_typed_errno (ofp, ECTF_NOTENUM);
return NULL;
}
@@ -318,20 +318,20 @@ ctf_enum_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
if ((void (*) (void)) ctf_enum_next != i->ctn_iter_fun)
{
- ctf_set_errno (ofp, ECTF_NEXT_WRONGFUN);
+ ctf_set_typed_errno (ofp, ECTF_NEXT_WRONGFUN);
return NULL;
}
if (ofp != i->cu.ctn_fp)
{
- ctf_set_errno (ofp, ECTF_NEXT_WRONGFP);
+ ctf_set_typed_errno (ofp, ECTF_NEXT_WRONGFP);
return NULL;
}
/* Resolve to the native dict of this type. */
if ((fp = ctf_get_dict (ofp, type)) == NULL)
{
- ctf_set_errno (ofp, ECTF_NOPARENT);
+ ctf_set_typed_errno (ofp, ECTF_NOPARENT);
return NULL;
}
@@ -349,7 +349,7 @@ ctf_enum_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
end_iter:
ctf_next_destroy (i);
*it = NULL;
- ctf_set_errno (ofp, ECTF_NEXT_END);
+ ctf_set_typed_errno (ofp, ECTF_NEXT_END);
return NULL;
}
@@ -426,7 +426,7 @@ ctf_type_next (ctf_dict_t *fp, ctf_next_t **it, int *flag, int want_hidden)
if (!i)
{
if ((i = ctf_next_create ()) == NULL)
- return ctf_set_errno (fp, ENOMEM);
+ return ctf_set_typed_errno (fp, ENOMEM);
i->cu.ctn_fp = fp;
i->ctn_type = 1;
@@ -435,10 +435,10 @@ ctf_type_next (ctf_dict_t *fp, ctf_next_t **it, int *flag, int want_hidden)
}
if ((void (*) (void)) ctf_type_next != i->ctn_iter_fun)
- return (ctf_set_errno (fp, ECTF_NEXT_WRONGFUN));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFUN));
if (fp != i->cu.ctn_fp)
- return (ctf_set_errno (fp, ECTF_NEXT_WRONGFP));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFP));
while (i->ctn_type <= fp->ctf_typemax)
{
@@ -456,7 +456,7 @@ ctf_type_next (ctf_dict_t *fp, ctf_next_t **it, int *flag, int want_hidden)
}
ctf_next_destroy (i);
*it = NULL;
- return ctf_set_errno (fp, ECTF_NEXT_END);
+ return ctf_set_typed_errno (fp, ECTF_NEXT_END);
}
/* Iterate over every variable in the given CTF dict, in arbitrary order.
@@ -494,12 +494,12 @@ ctf_variable_next (ctf_dict_t *fp, ctf_next_t **it, const char **name)
ctf_next_t *i = *it;
if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
- return (ctf_set_errno (fp, ECTF_NOPARENT));
+ return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
if (!i)
{
if ((i = ctf_next_create ()) == NULL)
- return ctf_set_errno (fp, ENOMEM);
+ return ctf_set_typed_errno (fp, ENOMEM);
i->cu.ctn_fp = fp;
i->ctn_iter_fun = (void (*) (void)) ctf_variable_next;
@@ -509,10 +509,10 @@ ctf_variable_next (ctf_dict_t *fp, ctf_next_t **it, const char **name)
}
if ((void (*) (void)) ctf_variable_next != i->ctn_iter_fun)
- return (ctf_set_errno (fp, ECTF_NEXT_WRONGFUN));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFUN));
if (fp != i->cu.ctn_fp)
- return (ctf_set_errno (fp, ECTF_NEXT_WRONGFP));
+ return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFP));
if (!(fp->ctf_flags & LCTF_RDWR))
{
@@ -538,7 +538,7 @@ ctf_variable_next (ctf_dict_t *fp, ctf_next_t **it, const char **name)
end_iter:
ctf_next_destroy (i);
*it = NULL;
- return ctf_set_errno (fp, ECTF_NEXT_END);
+ return ctf_set_typed_errno (fp, ECTF_NEXT_END);
}
/* Follow a given type through the graph for TYPEDEF, VOLATILE, CONST, and
@@ -560,7 +560,7 @@ ctf_type_resolve (ctf_dict_t *fp, ctf_id_t type)
const ctf_type_t *tp;
if (type == 0)
- return (ctf_set_errno (ofp, ECTF_NONREPRESENTABLE));
+ return (ctf_set_typed_errno (ofp, ECTF_NONREPRESENTABLE));
while ((tp = ctf_lookup_by_id (&fp, type)) != NULL)
{
@@ -575,18 +575,18 @@ ctf_type_resolve (ctf_dict_t *fp, ctf_id_t type)
{
ctf_err_warn (ofp, 0, ECTF_CORRUPT, _("type %lx cycle detected"),
otype);
- return (ctf_set_errno (ofp, ECTF_CORRUPT));
+ return (ctf_set_typed_errno (ofp, ECTF_CORRUPT));
}
prev = type;
type = tp->ctt_type;
break;
case CTF_K_UNKNOWN:
- return (ctf_set_errno (ofp, ECTF_NONREPRESENTABLE));
+ return (ctf_set_typed_errno (ofp, ECTF_NONREPRESENTABLE));
default:
return type;
}
if (type == 0)
- return (ctf_set_errno (ofp, ECTF_NONREPRESENTABLE));
+ return (ctf_set_typed_errno (ofp, ECTF_NONREPRESENTABLE));
}
return CTF_ERR; /* errno is set for us. */
@@ -612,7 +612,7 @@ ctf_type_resolve_unsliced (ctf_dict_t *fp, ctf_id_t type)
ctf_id_t ret;
if ((ret = ctf_type_reference (fp, type)) == CTF_ERR)
- return (ctf_set_errno (ofp, ctf_errno (fp)));
+ return (ctf_set_typed_errno (ofp, ctf_errno (fp)));
return ret;
}
return type;
@@ -675,7 +675,7 @@ ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
if (cd.cd_err != 0)
{
ctf_decl_fini (&cd);
- ctf_set_errno (fp, cd.cd_err);
+ ctf_set_typed_errno (fp, cd.cd_err);
return NULL;
}
@@ -720,7 +720,7 @@ ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
if (name[0] == '\0')
{
- ctf_set_errno (fp, ECTF_CORRUPT);
+ ctf_set_typed_errno (fp, ECTF_CORRUPT);
ctf_decl_fini (&cd);
return NULL;
}
@@ -744,7 +744,7 @@ ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
if ((argv = calloc (fi.ctc_argc, sizeof (ctf_id_t *))) == NULL)
{
- ctf_set_errno (rfp, errno);
+ ctf_set_typed_errno (rfp, errno);
goto err;
}
@@ -775,7 +775,7 @@ ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
break;
err:
- ctf_set_errno (fp, ctf_errno (rfp));
+ ctf_set_typed_errno (fp, ctf_errno (rfp));
free (argv);
ctf_decl_fini (&cd);
return NULL;
@@ -804,7 +804,7 @@ ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
ctf_decl_sprintf (&cd, "enum %s", name);
break;
default:
- ctf_set_errno (fp, ECTF_CORRUPT);
+ ctf_set_typed_errno (fp, ECTF_CORRUPT);
ctf_decl_fini (&cd);
return NULL;
}
@@ -836,7 +836,7 @@ ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
}
if (cd.cd_enomem)
- (void) ctf_set_errno (fp, ENOMEM);
+ (void) ctf_set_typed_errno (fp, ENOMEM);
buf = ctf_decl_buf (&cd);
@@ -854,7 +854,7 @@ ctf_type_lname (ctf_dict_t *fp, ctf_id_t type, char *buf, size_t len)
size_t slen;
if (str == NULL)
- return CTF_ERR; /* errno is set for us. */
+ return -1; /* errno is set for us. */
slen = strlen (str);
snprintf (buf, len, "%s", str);
@@ -1139,7 +1139,7 @@ ctf_type_reference (ctf_dict_t *fp, ctf_id_t type)
return sp->cts_type;
}
default:
- return (ctf_set_errno (ofp, ECTF_NOTREF));
+ return (ctf_set_typed_errno (ofp, ECTF_NOTREF));
}
}
@@ -1164,15 +1164,15 @@ ctf_type_pointer (ctf_dict_t *fp, ctf_id_t type)
return (LCTF_INDEX_TO_TYPE (fp, ntype, (fp->ctf_flags & LCTF_CHILD)));
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
- return (ctf_set_errno (ofp, ECTF_NOTYPE));
+ return (ctf_set_typed_errno (ofp, ECTF_NOTYPE));
if (ctf_lookup_by_id (&fp, type) == NULL)
- return (ctf_set_errno (ofp, ECTF_NOTYPE));
+ return (ctf_set_typed_errno (ofp, ECTF_NOTYPE));
if ((ntype = fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, type)]) != 0)
return (LCTF_INDEX_TO_TYPE (fp, ntype, (fp->ctf_flags & LCTF_CHILD)));
- return (ctf_set_errno (ofp, ECTF_NOTYPE));
+ return (ctf_set_typed_errno (ofp, ECTF_NOTYPE));
}
/* Return the encoding for the specified INTEGER, FLOAT, or ENUM. */
@@ -1494,7 +1494,7 @@ ctf_enum_name (ctf_dict_t *fp, ctf_id_t type, int value)
if (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ENUM)
{
- ctf_set_errno (ofp, ECTF_NOTENUM);
+ ctf_set_typed_errno (ofp, ECTF_NOTENUM);
return NULL;
}
@@ -1511,7 +1511,7 @@ ctf_enum_name (ctf_dict_t *fp, ctf_id_t type, int value)
return (ctf_strptr (fp, ep->cte_name));
}
- ctf_set_errno (ofp, ECTF_NOENUMNAM);
+ ctf_set_typed_errno (ofp, ECTF_NOENUMNAM);
return NULL;
}
@@ -1557,8 +1557,7 @@ ctf_enum_value (ctf_dict_t *fp, ctf_id_t type, const char *name, int *valp)
}
}
- ctf_set_errno (ofp, ECTF_NOENUMNAM);
- return -1;
+ return ctf_set_errno (ofp, ECTF_NOENUMNAM);
}
/* Given a type ID relating to a function type, return info on return types and
@@ -255,16 +255,6 @@ ctf_set_open_errno (int *errp, int error)
return NULL;
}
-/* Store the specified error code into the CTF dict, and then return CTF_ERR /
- -1 for the benefit of the caller. */
-
-unsigned long
-ctf_set_errno (ctf_dict_t *fp, int err)
-{
- fp->ctf_errno = err;
- return CTF_ERR;
-}
-
/* Create a ctf_next_t. */
ctf_next_t *