Imagelibrary/binutils-gdb
1
0
Fork 1
mirror of https://github.com/bminor/binutils-gdb.git synced 2025-11-16 12:34:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

libctf: more archive-related field renamings

Browse Source 
This one is definitely beneficial: ctf_archive_modent's ctf_offset
is just a bad name now it can be used as the offset of CTF, BTF,
or property values.  Just call it 'contents' instead (and drop
the 'offset' from the name_offset field as well.)
This commit is contained in:
Nick Alcock
2025-07-08 15:10:43 +01:00
parent 7c71bb7945
commit 8bc2641a13
2 changed files with 54 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
include/ctf.h
View File

@@ -873,11 +873,11 @@ struct ctf_archive
/* Number of shared properties. */
uint64_t nprops;
/* Offset of the name table, used for both CTF member names and property
/* Offset of the name table, used for both CTF/BTF member names and property
names. */
uint64_t names;
/* Offset of the CTF table. Each element starts with a size (a little-
/* Offset of the CTF/BTF table. Each element starts with a size (a little-
endian uint64_t) then a ctf_dict_t of that size. */
uint64_t ctfs;
@@ -919,11 +919,11 @@ struct ctf_archive_v1
};
/* An array of ctfa_ndicts of this structure lies at the offset given by
ctfa_modents (or, in v1, at ctf_archive[sizeof(struct ctf_archive)]) and gives
the ctfa_ctfs or ctfa_names-relative offsets of each name or ctf_dict_t.
ctfa_modents (or, in v1, at ctf_archive[sizeof(struct ctf_archive)]) and
gives the ctfs or names-relative offsets of each name or ctf_dict_t.
Another array of ctfa_nprops of this structure lies at the ctfa_propents
offset: for this, the ctf_offset is the ctfa_propents-relative offset of
offset: for this, the contents offset is the propents-relative offset of
proprty values.
Both property values and CTFs are prepended by a uint64 giving their length.
@@ -931,8 +931,8 @@ struct ctf_archive_v1
typedef struct ctf_archive_modent
{
uint64_t name_offset;
uint64_t ctf_offset;
uint64_t name;
uint64_t contents;
} ctf_archive_modent_t;
#ifdef __cplusplus

90
libctf/ctf-archive.c
View File

@@ -50,8 +50,9 @@ static int ctf_arc_range_check_hdr (struct ctf_archive_internal *arci, size_t,
static int ctf_arc_range_check_modents (ctf_archive_modent_t *modent,
struct ctf_archive *arc_hdr,
unsigned char *arc_bytes,
uint64_t ctf_base, size_t ctf_els,
size_t arc_len, int fixup_v1, int *errp);
uint64_t contents_base,
size_t contents_els, size_t arc_len,
int fixup_v1, int *errp);
static ctf_dict_t *ctf_dict_open_by_offset (const struct ctf_archive_internal *,
const ctf_sect_t *symsect,
const ctf_sect_t *strsect,
@@ -250,8 +251,8 @@ ctf_arc_write_fd (int fd, ctf_dict_t **ctf_dicts, size_t ctf_dict_cnt,
goto err_free;
}
modent->name_offset = namesz;
modent->ctf_offset = off - ctf_startoffs;
modent->name = namesz;
modent->contents = off - ctf_startoffs;
namesz += strlen (names[i]) + 1;
modent++;
@@ -313,8 +314,8 @@ ctf_arc_write_fd (int fd, ctf_dict_t **ctf_dicts, size_t ctf_dict_cnt,
memset (&props, 0, sizeof (ctf_archive_modent_t));
props.name_offset = prop_off;
props.ctf_offset = 0;
props.name = prop_off;
props.contents = 0;
if ((prop_values = arc_write_one (fd, known_parent,
strlen (known_parent) + 1, 1)) < 0
@@ -500,7 +501,7 @@ sort_modent_by_name (const void *one, const void *two, void *n)
const ctf_archive_modent_t *b = two;
char *nametbl = n;
return strcmp (&nametbl[a->name_offset], &nametbl[b->name_offset]);
return strcmp (&nametbl[a->name], &nametbl[b->name]);
}
/* bsearch_r() function to search for a given name in the sorted array of struct
@@ -516,7 +517,7 @@ search_modent_by_name (const void *key, const void *ent, void *arg)
arci = (const struct ctf_archive_internal *) arg;
search_nametbl = (char *) arci->ctfi_archive + arci->ctfi_hdr->names;
return strcmp (k, &search_nametbl[v->name_offset]);
return strcmp (k, &search_nametbl[v->name]);
}
/* Byteswap an archive (but not its members) if necessary. After this,
@@ -597,19 +598,19 @@ ctf_arc_flip_modents (ctf_archive_modent_t *modent, uint64_t els,
{
uint64_t *ctf_size;
swap_thing (modent[i].name_offset);
swap_thing (modent[i].ctf_offset);
swap_thing (modent[i].name);
swap_thing (modent[i].contents);
if (base + modent[i].ctf_offset + sizeof (uint64_t) > arc_len)
if (base + modent[i].contents + sizeof (uint64_t) > arc_len)
{
ctf_err_warn (NULL, 0, EOVERFLOW,
"CTF archive overflow in CTF offset for member %" PRIu64
" of %zi + %zi", i, base, modent[i].ctf_offset);
"CTF archive overflow in content offset for member %" PRIu64
" of %zi + %zi", i, base, modent[i].contents);
ctf_set_open_errno (errp, EOVERFLOW);
return -1;
}
ctf_size = (uint64_t *) (ents + modent[i].ctf_offset);
ctf_size = (uint64_t *) (ents + modent[i].contents);
swap_thing (*ctf_size);
}
@@ -771,14 +772,14 @@ static int
ctf_arc_range_check_modents (ctf_archive_modent_t *modent,
struct ctf_archive *arc_hdr,
unsigned char *arc_bytes,
uint64_t ctf_base, size_t ctf_els, size_t arc_len,
int fixup_v1, int *errp)
uint64_t contents_base, size_t contents_els,
size_t arc_len, int fixup_v1, int *errp)
{
uint64_t i;
char *names = (char *) arc_bytes + arc_hdr->names;
uint64_t name_base = arc_hdr->names;
unsigned char *ctfs = (unsigned char *) arc_bytes + ctf_base;
size_t closest_names_offset, closest_ctfs_offset;
unsigned char *contents = (unsigned char *) arc_bytes + contents_base;
size_t closest_names_offset, closest_contents_offset;
/* Figure out the offset of the thing that is closest to, but after the
end of, the names section, or the end of the file if none. */
@@ -786,14 +787,15 @@ ctf_arc_range_check_modents (ctf_archive_modent_t *modent,
closest_names_offset = arc_len;
closest_names_offset = ctf_arc_closest_section (arc_hdr, name_base, arc_len);
closest_ctfs_offset = ctf_arc_closest_section (arc_hdr, ctf_base, arc_len);
closest_contents_offset = ctf_arc_closest_section (arc_hdr, contents_base,
arc_len);
for (i = 0; i < ctf_els; i++)
for (i = 0; i < contents_els; i++)
{
uint64_t name_off = modent[i].name_offset + name_base;
uint64_t ctf_off = modent[i].ctf_offset + ctf_base;
uint64_t name_off = modent[i].name + name_base;
uint64_t contents_off = modent[i].contents + contents_base;
ssize_t space_left;
uint64_t *ctf_size;
uint64_t *contents_size;
/* We already checked for modent table overflow and overlap, but we
cannot check for name table overlap except member-by-member. We
@@ -801,7 +803,7 @@ ctf_arc_range_check_modents (ctf_archive_modent_t *modent,
the string is safe, then check that. */
if (name_off > closest_names_offset
|| (ctf_off + sizeof (uint64_t) > closest_ctfs_offset))
|| (contents_off + sizeof (uint64_t) > closest_contents_offset))
goto err;
space_left = closest_names_offset - name_off;
@@ -809,15 +811,16 @@ ctf_arc_range_check_modents (ctf_archive_modent_t *modent,
if (space_left < 0)
goto err;
if (strnlen (&names[modent[i].name_offset], space_left)
if (strnlen (&names[modent[i].name], space_left)
== (size_t) space_left)
goto err;
/* Checking the CTF offset is simpler: we already checked that the
actual size didn't overflow, so now we just need to make sure that
the entire dict (or, depending on the call, property value) fits. */
/* Checking the contents offset is simpler: we already checked that
the actual size didn't overflow, so now we just need to make sure
that the entire dict (or, depending on the call, property value)
fits. */
ctf_size = (uint64_t *) (ctfs + modent[i].ctf_offset);
contents_size = (uint64_t *) (contents + modent[i].contents);
/* If this was a v1 archive, the size is actually wrong: it includes
the size of the size uint64_t itself, so all archive opens opened
@@ -827,12 +830,13 @@ ctf_arc_range_check_modents (ctf_archive_modent_t *modent,
if (fixup_v1)
{
if (*ctf_size < sizeof (uint64_t))
if (*contents_size < sizeof (uint64_t))
goto err;
*ctf_size -= sizeof (uint64_t);
*contents_size -= sizeof (uint64_t);
}
if (ctf_off + sizeof (uint64_t) + *ctf_size > closest_ctfs_offset)
if (contents_off + sizeof (uint64_t) + *contents_size
> closest_contents_offset)
goto err;
}
@@ -1156,7 +1160,7 @@ ctf_dict_open_internal (const struct ctf_archive_internal *arci,
return NULL;
}
return ctf_dict_open_by_offset (arci, symsect, strsect, modent->ctf_offset,
return ctf_dict_open_by_offset (arci, symsect, strsect, modent->contents,
little_endian_symtab, errp);
}
@@ -1387,13 +1391,13 @@ ctf_arc_get_property (const struct ctf_archive_internal *arci, const char *prop)
size = (uint64_t *) (arci->ctfi_archive
+ arci->ctfi_hdr->propents
+ modent->ctf_offset);
+ modent->contents);
if (*size == 0)
return "";
return (char *) (arci->ctfi_archive
+ arci->ctfi_hdr->propents
+ modent->ctf_offset
+ modent->contents
+ sizeof (uint64_t));
}
@@ -1806,17 +1810,17 @@ ctf_archive_raw_iter (const struct ctf_archive_internal *arci,
{
const char *name;
unsigned char *content;
size_t name_offset, ctf_offset, ctf_size;
size_t name_off, content_off, content_size;
name_offset = modent[i].name_offset;
ctf_offset = modent[i].ctf_offset;
name_off = modent[i].name;
content_off = modent[i].contents;
name = &nametbl[name_offset];
content = arci->ctfi_archive + arci->ctfi_hdr->ctfs + ctf_offset;
ctf_size = *((uint64_t *) content);
name = &nametbl[name_off];
content = arci->ctfi_archive + arci->ctfi_hdr->ctfs + content_off;
content_size = *((uint64_t *) content);
if ((rc = func (name, (void *) (content + sizeof (uint64_t)),
ctf_size, data)) != 0)
content_size, data)) != 0)
return rc;
}
return 0;
@@ -1934,7 +1938,7 @@ ctf_archive_next (const struct ctf_archive_internal *arci, ctf_next_t **it,
modent = (ctf_archive_modent_t *) ((char *) arci->ctfi_archive
+ arci->ctfi_hdr->modents);
nametbl = (const char *) arci->ctfi_archive + arci->ctfi_hdr->names;
name_ = &nametbl[modent[i->ctn_n].name_offset];
name_ = &nametbl[modent[i->ctn_n].name];
i->ctn_n++;
}
while (skip_parent && strcmp (name_, _CTF_SECTION) == 0);