4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
27 * Routines for preparing tdata trees for conversion into CTF data, and
28 * for placing the resulting data into an output file.
34 #include <sys/types.h>
47 typedef struct iidesc_match {
56 burst_iitypes(void *data, void *arg)
59 iiburst_t *iiburst = arg;
61 switch (ii->ii_type) {
66 if (!(ii->ii_flags & IIDESC_F_USED))
73 ii->ii_dtype->t_flags |= TDESC_F_ISROOT;
74 (void) iitraverse_td(ii, iiburst->iib_tdtd);
80 save_type_by_id(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private)
82 iiburst_t *iiburst = private;
85 * Doing this on every node is horribly inefficient, but given that
86 * we may be suppressing some types, we can't trust nextid in the
89 if (tdp->t_id > iiburst->iib_maxtypeid)
90 iiburst->iib_maxtypeid = tdp->t_id;
92 slist_add(&iiburst->iib_types, tdp, tdesc_idcmp);
97 static tdtrav_cb_f burst_types_cbs[] = {
99 save_type_by_id, /* intrinsic */
100 save_type_by_id, /* pointer */
101 save_type_by_id, /* array */
102 save_type_by_id, /* function */
103 save_type_by_id, /* struct */
104 save_type_by_id, /* union */
105 save_type_by_id, /* enum */
106 save_type_by_id, /* forward */
107 save_type_by_id, /* typedef */
108 tdtrav_assert, /* typedef_unres */
109 save_type_by_id, /* volatile */
110 save_type_by_id, /* const */
111 save_type_by_id /* restrict */
116 iiburst_new(tdata_t *td, int max)
118 iiburst_t *iiburst = xcalloc(sizeof (iiburst_t));
119 iiburst->iib_td = td;
120 iiburst->iib_funcs = xcalloc(sizeof (iidesc_t *) * max);
121 iiburst->iib_nfuncs = 0;
122 iiburst->iib_objts = xcalloc(sizeof (iidesc_t *) * max);
123 iiburst->iib_nobjts = 0;
128 iiburst_types(iiburst_t *iiburst)
132 tdtrav_init(&tdtd, &iiburst->iib_td->td_curvgen, NULL, burst_types_cbs,
133 NULL, (void *)iiburst);
135 iiburst->iib_tdtd = &tdtd;
137 (void) hash_iter(iiburst->iib_td->td_iihash, burst_iitypes, iiburst);
141 iiburst_free(iiburst_t *iiburst)
143 free(iiburst->iib_funcs);
144 free(iiburst->iib_objts);
145 list_free(iiburst->iib_types, NULL, NULL);
150 * See if this iidesc matches the ELF symbol data we pass in.
152 * A fuzzy match is where we have a local symbol matching the name of a
153 * global type description. This is common when a mapfile is used for a
154 * DSO, but we don't accept it by default.
156 * A weak fuzzy match is when a weak symbol was resolved and matched to
157 * a global type description.
160 matching_iidesc(void *arg1, void *arg2)
162 iidesc_t *iidesc = arg1;
163 iidesc_match_t *match = arg2;
164 if (streq(iidesc->ii_name, match->iim_name) == 0)
167 switch (iidesc->ii_type) {
170 if (match->iim_bind == STB_GLOBAL) {
171 match->iim_ret = iidesc;
173 } else if (match->iim_fuzzy && match->iim_ret == NULL) {
174 match->iim_ret = iidesc;
175 /* continue to look for strong match */
181 if (match->iim_bind == STB_LOCAL &&
182 match->iim_file != NULL &&
183 streq(iidesc->ii_owner, match->iim_file)) {
184 match->iim_ret = iidesc;
195 find_iidesc(tdata_t *td, iidesc_match_t *match)
197 match->iim_ret = NULL;
198 iter_iidescs_by_name(td, match->iim_name,
199 matching_iidesc, match);
200 return (match->iim_ret);
204 * If we have a weak symbol, attempt to find the strong symbol it will
205 * resolve to. Note: the code where this actually happens is in
206 * sym_process() in cmd/sgs/libld/common/syms.c
208 * Finding the matching symbol is unfortunately not trivial. For a
209 * symbol to be a candidate, it must:
211 * - have the same type (function, object)
212 * - have the same value (address)
213 * - have the same size
214 * - not be another weak symbol
215 * - belong to the same section (checked via section index)
217 * If such a candidate is global, then we assume we've found it. The
218 * linker generates the symbol table such that the curfile might be
219 * incorrect; this is OK for global symbols, since find_iidesc() doesn't
220 * need to check for the source file for the symbol.
222 * We might have found a strong local symbol, where the curfile is
223 * accurate and matches that of the weak symbol. We assume this is a
226 * If we've got a local symbol with a non-matching curfile, there are
227 * two possibilities. Either this is a completely different symbol, or
228 * it's a once-global symbol that was scoped to local via a mapfile. In
229 * the latter case, curfile is likely inaccurate since the linker does
230 * not preserve the needed curfile in the order of the symbol table (see
231 * the comments about locally scoped symbols in libld's update_osym()).
232 * As we can't tell this case from the former one, we use this symbol
233 * iff no other matching symbol is found.
235 * What we really need here is a SUNW section containing weak<->strong
236 * mappings that we can consume.
239 check_for_weak(GElf_Sym *weak, char const *weakfile,
240 Elf_Data *data, int nent, Elf_Data *strdata,
241 GElf_Sym *retsym, char **curfilep)
243 char *curfile = NULL;
244 char *tmpfile1 = NULL;
251 if (GELF_ST_BIND(weak->st_info) != STB_WEAK)
254 for (i = 0; i < nent; i++) {
258 if (gelf_getsym(data, i, &sym) == NULL)
261 type = GELF_ST_TYPE(sym.st_info);
263 if (type == STT_FILE)
264 curfile = (char *)strdata->d_buf + sym.st_name;
266 if (GELF_ST_TYPE(weak->st_info) != type ||
267 weak->st_value != sym.st_value)
270 if (weak->st_size != sym.st_size)
273 if (GELF_ST_BIND(sym.st_info) == STB_WEAK)
276 if (sym.st_shndx != weak->st_shndx)
279 if (GELF_ST_BIND(sym.st_info) == STB_LOCAL &&
280 (curfile == NULL || weakfile == NULL ||
281 strcmp(curfile, weakfile) != 0)) {
294 *curfilep = tmpfile1;
303 * When we've found the underlying symbol's type description
304 * for a weak symbol, we need to copy it and rename it to match
305 * the weak symbol. We also need to add it to the td so it's
306 * handled along with the others later.
309 copy_from_strong(tdata_t *td, GElf_Sym *sym, iidesc_t *strongdesc,
310 const char *weakname, const char *weakfile)
312 iidesc_t *new = iidesc_dup_rename(strongdesc, weakname, weakfile);
313 uchar_t type = GELF_ST_TYPE(sym->st_info);
317 new->ii_type = II_GVAR;
320 new->ii_type = II_GFUN;
324 hash_add(td->td_iihash, new);
330 * Process the symbol table of the output file, associating each symbol
331 * with a type description if possible, and sorting them into functions
332 * and data, maintaining symbol table order.
335 sort_iidescs(Elf *elf, const char *file, tdata_t *td, int fuzzymatch,
341 Elf_Data *data, *strdata;
344 iidesc_match_t match;
346 match.iim_fuzzy = fuzzymatch;
347 match.iim_file = NULL;
349 if ((stidx = findelfsecidx(elf, file,
350 dynsym ? ".dynsym" : ".symtab")) < 0)
351 terminate("%s: Can't open symbol table\n", file);
352 scn = elf_getscn(elf, stidx);
353 data = elf_getdata(scn, NULL);
354 gelf_getshdr(scn, &shdr);
355 nent = shdr.sh_size / shdr.sh_entsize;
357 scn = elf_getscn(elf, shdr.sh_link);
358 strdata = elf_getdata(scn, NULL);
360 iiburst = iiburst_new(td, nent);
362 for (i = 0; i < nent; i++) {
367 iidesc_match_t smatch;
371 if (gelf_getsym(data, i, &sym) == NULL)
372 elfterminate(file, "Couldn't read symbol %d", i);
374 match.iim_name = (char *)strdata->d_buf + sym.st_name;
375 match.iim_bind = GELF_ST_BIND(sym.st_info);
377 switch (GELF_ST_TYPE(sym.st_info)) {
379 bname = strrchr(match.iim_name, '/');
380 match.iim_file = bname == NULL ? match.iim_name : bname + 1;
383 tolist = iiburst->iib_objts;
384 curr = &iiburst->iib_nobjts;
387 tolist = iiburst->iib_funcs;
388 curr = &iiburst->iib_nfuncs;
394 if (ignore_symbol(&sym, match.iim_name))
397 iidesc = find_iidesc(td, &match);
399 if (iidesc != NULL) {
400 tolist[*curr] = iidesc;
401 iidesc->ii_flags |= IIDESC_F_USED;
406 if (!check_for_weak(&sym, match.iim_file, data, nent, strdata,
407 &ssym, &smatch.iim_file)) {
412 smatch.iim_fuzzy = fuzzymatch;
413 smatch.iim_name = (char *)strdata->d_buf + ssym.st_name;
414 smatch.iim_bind = GELF_ST_BIND(ssym.st_info);
416 debug(3, "Weak symbol %s resolved to %s\n", match.iim_name,
419 iidesc = find_iidesc(td, &smatch);
421 if (iidesc != NULL) {
422 tolist[*curr] = copy_from_strong(td, &sym,
423 iidesc, match.iim_name, match.iim_file);
424 tolist[*curr]->ii_flags |= IIDESC_F_USED;
431 * Stabs are generated for every function declared in a given C source
432 * file. When converting an object file, we may encounter a stab that
433 * has no symbol table entry because the optimizer has decided to omit
434 * that item (for example, an unreferenced static function). We may
435 * see iidescs that do not have an associated symtab entry, and so
436 * we do not write records for those functions into the CTF data.
437 * All others get marked as a root by this function.
439 iiburst_types(iiburst);
442 * By not adding some of the functions and/or objects, we may have
443 * caused some types that were referenced solely by those
444 * functions/objects to be suppressed. This could cause a label,
445 * generated prior to the evisceration, to be incorrect. Find the
446 * highest type index, and change the label indicies to be no higher
449 tdata_label_newmax(td, iiburst->iib_maxtypeid);
455 write_file(Elf *src, const char *srcname, Elf *dst, const char *dstname,
456 caddr_t ctfdata, size_t ctfsize, int flags)
458 GElf_Ehdr sehdr, dehdr;
459 Elf_Scn *sscn, *dscn;
460 Elf_Data *sdata, *ddata;
462 GElf_Word symtab_type;
464 off_t new_offset = 0;
465 off_t ctfnameoff = 0;
466 int dynsym = (flags & CTF_USE_DYNSYM);
467 int keep_stabs = (flags & CTF_KEEP_STABS);
474 if (gelf_newehdr(dst, gelf_getclass(src)) == NULL)
475 elfterminate(dstname, "Cannot copy ehdr to temp file");
476 gelf_getehdr(src, &sehdr);
477 memcpy(&dehdr, &sehdr, sizeof (GElf_Ehdr));
478 gelf_update_ehdr(dst, &dehdr);
480 symtab_type = dynsym ? SHT_DYNSYM : SHT_SYMTAB;
483 * Neither the existing stab sections nor the SUNW_ctf sections (new or
484 * existing) are SHF_ALLOC'd, so they won't be in areas referenced by
485 * program headers. As such, we can just blindly copy the program
486 * headers from the existing file to the new file.
488 if (sehdr.e_phnum != 0) {
489 (void) elf_flagelf(dst, ELF_C_SET, ELF_F_LAYOUT);
490 if (gelf_newphdr(dst, sehdr.e_phnum) == NULL)
491 elfterminate(dstname, "Cannot make phdrs in temp file");
493 for (i = 0; i < sehdr.e_phnum; i++) {
496 gelf_getphdr(src, i, &phdr);
497 gelf_update_phdr(dst, i, &phdr);
501 secxlate = xmalloc(sizeof (int) * sehdr.e_shnum);
502 for (srcidx = dstidx = 0; srcidx < sehdr.e_shnum; srcidx++) {
503 Elf_Scn *scn = elf_getscn(src, srcidx);
507 gelf_getshdr(scn, &shdr1);
508 sname = elf_strptr(src, sehdr.e_shstrndx, shdr1.sh_name);
510 elfterminate(srcname, "Can't find string at %u",
514 if (strcmp(sname, CTF_ELF_SCN_NAME) == 0) {
515 secxlate[srcidx] = -1;
516 } else if (!keep_stabs &&
517 (strncmp(sname, ".stab", 5) == 0 ||
518 strncmp(sname, ".debug", 6) == 0 ||
519 strncmp(sname, ".rel.debug", 10) == 0 ||
520 strncmp(sname, ".rela.debug", 11) == 0)) {
521 secxlate[srcidx] = -1;
522 } else if (dynsym && shdr1.sh_type == SHT_SYMTAB) {
524 * If we're building CTF against the dynsym,
525 * we'll rip out the symtab so debuggers aren't
528 secxlate[srcidx] = -1;
530 secxlate[srcidx] = dstidx++;
533 new_offset = (off_t)dehdr.e_phoff;
536 for (srcidx = 1; srcidx < sehdr.e_shnum; srcidx++) {
539 sscn = elf_getscn(src, srcidx);
540 gelf_getshdr(sscn, &shdr);
542 if (secxlate[srcidx] == -1) {
547 dscn = elf_newscn(dst);
550 * If this file has program headers, we need to explicitly lay
551 * out sections. If none of the sections prior to this one have
552 * been removed, then we can just use the existing location. If
553 * one or more sections have been changed, then we need to
554 * adjust this one to avoid holes.
556 if (changing && sehdr.e_phnum != 0) {
557 pad = new_offset % shdr.sh_addralign;
560 new_offset += shdr.sh_addralign - pad;
561 shdr.sh_offset = new_offset;
564 shdr.sh_link = secxlate[shdr.sh_link];
566 if (shdr.sh_type == SHT_REL || shdr.sh_type == SHT_RELA)
567 shdr.sh_info = secxlate[shdr.sh_info];
569 sname = elf_strptr(src, sehdr.e_shstrndx, shdr.sh_name);
571 elfterminate(srcname, "Can't find string at %u",
576 if (gelf_update_shdr(dscn, &shdr) == 0)
577 elfterminate(dstname, "Cannot update sect %s", sname);
580 if ((sdata = elf_getdata(sscn, NULL)) == NULL)
581 elfterminate(srcname, "Cannot get sect %s data", sname);
582 if ((ddata = elf_newdata(dscn)) == NULL)
583 elfterminate(dstname, "Can't make sect %s data", sname);
585 bcopy(sdata, ddata, sizeof (Elf_Data));
588 * FreeBSD's Elf_Data has private fields which the
589 * elf_* routines manage. Simply copying the
590 * entire structure corrupts the data. So we need
591 * to copy the public fields explictly.
593 ddata->d_align = sdata->d_align;
594 ddata->d_off = sdata->d_off;
595 ddata->d_size = sdata->d_size;
596 ddata->d_type = sdata->d_type;
597 ddata->d_version = sdata->d_version;
600 if (srcidx == sehdr.e_shstrndx) {
601 char seclen = strlen(CTF_ELF_SCN_NAME);
603 ddata->d_buf = xmalloc(ddata->d_size + shdr.sh_size +
605 bcopy(sdata->d_buf, ddata->d_buf, shdr.sh_size);
606 strcpy((caddr_t)ddata->d_buf + shdr.sh_size,
608 ctfnameoff = (off_t)shdr.sh_size;
609 shdr.sh_size += seclen + 1;
610 ddata->d_size += seclen + 1;
612 if (sehdr.e_phnum != 0)
616 if (shdr.sh_type == symtab_type && shdr.sh_entsize != 0) {
617 int nsym = shdr.sh_size / shdr.sh_entsize;
619 symtab_idx = secxlate[srcidx];
621 ddata->d_buf = xmalloc(shdr.sh_size);
622 bcopy(sdata->d_buf, ddata->d_buf, shdr.sh_size);
624 for (i = 0; i < nsym; i++) {
628 if (gelf_getsym(ddata, i, &sym) == NULL)
629 printf("Could not get symbol %d\n",i);
631 if (sym.st_shndx >= SHN_LORESERVE)
634 if ((newscn = secxlate[sym.st_shndx]) !=
637 (newscn == -1 ? 1 : newscn);
639 gelf_update_sym(ddata, i, &sym);
645 if (ddata->d_buf == NULL && sdata->d_buf != NULL) {
646 ddata->d_buf = xmalloc(shdr.sh_size);
647 bcopy(sdata->d_buf, ddata->d_buf, shdr.sh_size);
651 if (gelf_update_shdr(dscn, &shdr) == 0)
652 elfterminate(dstname, "Cannot update sect %s", sname);
654 new_offset = (off_t)shdr.sh_offset;
655 if (shdr.sh_type != SHT_NOBITS)
656 new_offset += shdr.sh_size;
659 if (symtab_idx == -1) {
660 terminate("%s: Cannot find %s section\n", srcname,
661 dynsym ? "SHT_DYNSYM" : "SHT_SYMTAB");
664 /* Add the ctf section */
665 dscn = elf_newscn(dst);
666 gelf_getshdr(dscn, &shdr);
667 shdr.sh_name = ctfnameoff;
668 shdr.sh_type = SHT_PROGBITS;
669 shdr.sh_size = ctfsize;
670 shdr.sh_link = symtab_idx;
671 shdr.sh_addralign = 4;
672 if (changing && sehdr.e_phnum != 0) {
673 pad = new_offset % shdr.sh_addralign;
676 new_offset += shdr.sh_addralign - pad;
678 shdr.sh_offset = new_offset;
679 new_offset += shdr.sh_size;
682 ddata = elf_newdata(dscn);
683 ddata->d_buf = ctfdata;
684 ddata->d_size = ctfsize;
685 ddata->d_align = shdr.sh_addralign;
688 gelf_update_shdr(dscn, &shdr);
690 /* update the section header location */
691 if (sehdr.e_phnum != 0) {
692 size_t align = gelf_fsize(dst, ELF_T_ADDR, 1, EV_CURRENT);
693 size_t r = new_offset % align;
696 new_offset += align - r;
698 dehdr.e_shoff = new_offset;
702 dehdr.e_shstrndx = secxlate[sehdr.e_shstrndx];
703 gelf_update_ehdr(dst, &dehdr);
704 if (elf_update(dst, ELF_C_WRITE) < 0)
705 elfterminate(dstname, "Cannot finalize temp file");
711 make_ctf_data(tdata_t *td, Elf *elf, const char *file, size_t *lenp, int flags)
716 iiburst = sort_iidescs(elf, file, td, flags & CTF_FUZZY_MATCH,
717 flags & CTF_USE_DYNSYM);
718 data = ctf_gen(iiburst, lenp, flags & (CTF_COMPRESS | CTF_SWAP_BYTES));
720 iiburst_free(iiburst);
726 write_ctf(tdata_t *td, const char *curname, const char *newname, int flags)
738 (void) elf_version(EV_CURRENT);
739 if ((fd = open(curname, O_RDONLY)) < 0 || fstat(fd, &st) < 0)
740 terminate("%s: Cannot open for re-reading", curname);
741 if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL)
742 elfterminate(curname, "Cannot re-read");
744 if ((tfd = open(newname, O_RDWR | O_CREAT | O_TRUNC, st.st_mode)) < 0)
745 terminate("Cannot open temp file %s for writing", newname);
746 if ((telf = elf_begin(tfd, ELF_C_WRITE, NULL)) == NULL)
747 elfterminate(curname, "Cannot write");
749 if (gelf_getehdr(elf, &ehdr)) {
750 #if BYTE_ORDER == _BIG_ENDIAN
751 byteorder = ELFDATA2MSB;
753 byteorder = ELFDATA2LSB;
756 * If target and host has the same byte order
757 * clear byte swapping request
759 if (ehdr.e_ident[EI_DATA] == byteorder)
760 flags &= ~CTF_SWAP_BYTES;
763 elfterminate(curname, "Failed to get EHDR");
765 data = make_ctf_data(td, elf, curname, &len, flags);
766 write_file(elf, curname, telf, newname, data, len, flags);