caddr_t
ctf_gen(iiburst_t *iiburst, size_t *resszp, int do_compress)
{
ctf_buf_t *buf = ctf_buf_new();
ctf_header_t h;
caddr_t outbuf;
int i;
/*
* Prepare the header, and create the CTF output buffers. The data
* object section and function section are both lists of 2-byte
* integers; we pad these out to the next 4-byte boundary if needed.
*/
h.cth_magic = CTF_MAGIC;
h.cth_version = CTF_VERSION;
h.cth_flags = do_compress ? CTF_F_COMPRESS : 0;
h.cth_parlabel = strtab_insert(&buf->ctb_strtab,
iiburst->iib_td->td_parlabel);
h.cth_parname = strtab_insert(&buf->ctb_strtab,
iiburst->iib_td->td_parname);
h.cth_lbloff = 0;
(void) list_iter(iiburst->iib_td->td_labels, write_label,
buf);
pad_buffer(buf, 2);
h.cth_objtoff = ctf_buf_cur(buf);
for (i = 0; i < iiburst->iib_nobjts; i++)
write_objects(iiburst->iib_objts[i], buf);
pad_buffer(buf, 2);
h.cth_funcoff = ctf_buf_cur(buf);
for (i = 0; i < iiburst->iib_nfuncs; i++)
write_functions(iiburst->iib_funcs[i], buf);
pad_buffer(buf, 4);
h.cth_typeoff = ctf_buf_cur(buf);
(void) list_iter(iiburst->iib_types, write_type, buf);
debug(2, "CTF wrote %d types\n", list_count(iiburst->iib_types));
h.cth_stroff = ctf_buf_cur(buf);
h.cth_strlen = strtab_size(&buf->ctb_strtab);
/*
* We only do compression for ctfmerge, as ctfconvert is only
* supposed to be used on intermediary build objects. This is
* significantly faster.
*/
if (do_compress)
outbuf = write_compressed_buffer(&h, buf, resszp);
else
outbuf = write_buffer(&h, buf, resszp);
ctf_buf_free(buf);
return (outbuf);
}
static int
write_label(void *arg1, void *arg2)
{
labelent_t *le = arg1;
ctf_buf_t *b = arg2;
ctf_lblent_t ctl;
ctl.ctl_label = strtab_insert(&b->ctb_strtab, le->le_name);
ctl.ctl_typeidx = le->le_idx;
ctf_buf_write(b, &ctl, sizeof (ctl));
return (1);
}
static int
write_label(void *arg1, void *arg2)
{
labelent_t *le = arg1;
ctf_buf_t *b = arg2;
ctf_lblent_t ctl;
ctl.ctl_label = strtab_insert(&b->ctb_strtab, le->le_name);
ctl.ctl_typeidx = le->le_idx;
if (target_requires_swap) {
SWAP_32(ctl.ctl_label);
SWAP_32(ctl.ctl_typeidx);
}
ctf_buf_write(b, &ctl, sizeof (ctl));
return (1);
}
static int
write_type(void *arg1, void *arg2)
{
tdesc_t *tp = arg1;
ctf_buf_t *b = arg2;
elist_t *ep;
mlist_t *mp;
intr_t *ip;
size_t offset;
uint_t encoding;
uint_t data;
int isroot = tp->t_flags & TDESC_F_ISROOT;
int i;
ctf_type_t ctt;
ctf_array_t cta;
ctf_member_t ctm;
ctf_lmember_t ctlm;
ctf_enum_t cte;
ushort_t id;
ctlm.ctlm_pad = 0;
/*
* There shouldn't be any holes in the type list (where a hole is
* defined as two consecutive tdescs without consecutive ids), but
* check for them just in case. If we do find holes, we need to make
* fake entries to fill the holes, or we won't be able to reconstruct
* the tree from the written data.
*/
if (++b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) {
debug(2, "genctf: type hole from %d < x < %d\n",
b->nptent - 1, CTF_TYPE_TO_INDEX(tp->t_id));
ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, 0);
ctt.ctt_info = CTF_TYPE_INFO(0, 0, 0);
while (b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) {
write_sized_type_rec(b, &ctt, 0);
b->nptent++;
}
}
offset = strtab_insert(&b->ctb_strtab, tp->t_name);
ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset);
switch (tp->t_type) {
case INTRINSIC:
ip = tp->t_intr;
if (ip->intr_type == INTR_INT)
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_INTEGER,
isroot, 1);
else
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FLOAT, isroot, 1);
write_sized_type_rec(b, &ctt, tp->t_size);
encoding = 0;
if (ip->intr_type == INTR_INT) {
if (ip->intr_signed)
encoding |= CTF_INT_SIGNED;
if (ip->intr_iformat == 'c')
encoding |= CTF_INT_CHAR;
else if (ip->intr_iformat == 'b')
encoding |= CTF_INT_BOOL;
else if (ip->intr_iformat == 'v')
encoding |= CTF_INT_VARARGS;
} else
encoding = ip->intr_fformat;
data = CTF_INT_DATA(encoding, ip->intr_offset, ip->intr_nbits);
if (target_requires_swap) {
SWAP_32(data);
}
ctf_buf_write(b, &data, sizeof (data));
break;
case POINTER:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_POINTER, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case ARRAY:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ARRAY, isroot, 1);
write_sized_type_rec(b, &ctt, tp->t_size);
cta.cta_contents = tp->t_ardef->ad_contents->t_id;
cta.cta_index = tp->t_ardef->ad_idxtype->t_id;
cta.cta_nelems = tp->t_ardef->ad_nelems;
if (target_requires_swap) {
SWAP_16(cta.cta_contents);
SWAP_16(cta.cta_index);
SWAP_32(cta.cta_nelems);
}
ctf_buf_write(b, &cta, sizeof (cta));
break;
case STRUCT:
case UNION:
for (i = 0, mp = tp->t_members; mp != NULL; mp = mp->ml_next)
i++; /* count up struct or union members */
if (i > CTF_MAX_VLEN) {
terminate("sou %s has too many members: %d > %d\n",
tdesc_name(tp), i, CTF_MAX_VLEN);
}
if (tp->t_type == STRUCT)
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_STRUCT, isroot, i);
else
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_UNION, isroot, i);
write_sized_type_rec(b, &ctt, tp->t_size);
if (tp->t_size < CTF_LSTRUCT_THRESH) {
for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) {
offset = strtab_insert(&b->ctb_strtab,
mp->ml_name);
ctm.ctm_name = CTF_TYPE_NAME(CTF_STRTAB_0,
offset);
ctm.ctm_type = mp->ml_type->t_id;
ctm.ctm_offset = mp->ml_offset;
if (target_requires_swap) {
SWAP_32(ctm.ctm_name);
SWAP_16(ctm.ctm_type);
SWAP_16(ctm.ctm_offset);
}
ctf_buf_write(b, &ctm, sizeof (ctm));
}
} else {
for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) {
offset = strtab_insert(&b->ctb_strtab,
mp->ml_name);
ctlm.ctlm_name = CTF_TYPE_NAME(CTF_STRTAB_0,
offset);
ctlm.ctlm_type = mp->ml_type->t_id;
ctlm.ctlm_offsethi =
CTF_OFFSET_TO_LMEMHI(mp->ml_offset);
ctlm.ctlm_offsetlo =
CTF_OFFSET_TO_LMEMLO(mp->ml_offset);
if (target_requires_swap) {
SWAP_32(ctlm.ctlm_name);
SWAP_16(ctlm.ctlm_type);
SWAP_32(ctlm.ctlm_offsethi);
SWAP_32(ctlm.ctlm_offsetlo);
}
ctf_buf_write(b, &ctlm, sizeof (ctlm));
}
}
break;
case ENUM:
for (i = 0, ep = tp->t_emem; ep != NULL; ep = ep->el_next)
i++; /* count up enum members */
if (i > CTF_MAX_VLEN) {
warning("enum %s has too many values: %d > %d\n",
tdesc_name(tp), i, CTF_MAX_VLEN);
i = CTF_MAX_VLEN;
}
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ENUM, isroot, i);
write_sized_type_rec(b, &ctt, tp->t_size);
for (ep = tp->t_emem; ep != NULL && i > 0; ep = ep->el_next) {
offset = strtab_insert(&b->ctb_strtab, ep->el_name);
cte.cte_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset);
cte.cte_value = ep->el_number;
if (target_requires_swap) {
SWAP_32(cte.cte_name);
SWAP_32(cte.cte_value);
}
ctf_buf_write(b, &cte, sizeof (cte));
i--;
}
break;
case FORWARD:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FORWARD, isroot, 0);
ctt.ctt_type = 0;
write_unsized_type_rec(b, &ctt);
break;
case TYPEDEF:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_TYPEDEF, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case VOLATILE:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_VOLATILE, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case CONST:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_CONST, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case FUNCTION:
i = tp->t_fndef->fn_nargs + tp->t_fndef->fn_vargs;
if (i > CTF_MAX_VLEN) {
terminate("function %s has too many args: %d > %d\n",
tdesc_name(tp), i, CTF_MAX_VLEN);
}
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FUNCTION, isroot, i);
ctt.ctt_type = tp->t_fndef->fn_ret->t_id;
write_unsized_type_rec(b, &ctt);
for (i = 0; i < (int) tp->t_fndef->fn_nargs; i++) {
id = tp->t_fndef->fn_args[i]->t_id;
if (target_requires_swap) {
SWAP_16(id);
}
ctf_buf_write(b, &id, sizeof (id));
}
if (tp->t_fndef->fn_vargs) {
id = 0;
ctf_buf_write(b, &id, sizeof (id));
i++;
}
if (i & 1) {
id = 0;
ctf_buf_write(b, &id, sizeof (id));
}
break;
case RESTRICT:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_RESTRICT, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
default:
warning("Can't write unknown type %d\n", tp->t_type);
}
debug(3, "Wrote type %d %s\n", tp->t_id, tdesc_name(tp));
return (1);
}