1 /*-
2  * Copyright (c) 2007-2013 Kai Wang
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/param.h>
28 #include <assert.h>
29 #include <err.h>
30 #include <fnmatch.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 
35 #include "elfcopy.h"
36 
37 ELFTC_VCSID("$Id: symbols.c 3520 2017-04-17 01:47:52Z kaiwang27 $");
38 
39 /* Backwards compatibility for systems with older ELF definitions. */
40 #ifndef STB_GNU_UNIQUE
41 #define	STB_GNU_UNIQUE 10
42 #endif
43 
44 
45 /* Symbol table buffer structure. */
46 struct symbuf {
47 	Elf32_Sym *l32;		/* 32bit local symbol */
48 	Elf32_Sym *g32;		/* 32bit global symbol */
49 	Elf64_Sym *l64;		/* 64bit local symbol */
50 	Elf64_Sym *g64;		/* 64bit global symbol */
51 	size_t ngs, nls;	/* number of each kind */
52 	size_t gcap, lcap; 	/* buffer capacities. */
53 };
54 
55 struct sthash {
56 	LIST_ENTRY(sthash) sh_next;
57 	size_t sh_off;
58 };
59 typedef LIST_HEAD(,sthash) hash_head;
60 #define STHASHSIZE 65536
61 
62 struct strimpl {
63 	char *buf;		/* string table */
64 	size_t sz;		/* entries */
65 	size_t cap;		/* buffer capacity */
66 	hash_head hash[STHASHSIZE];
67 };
68 
69 
70 /* String table buffer structure. */
71 struct strbuf {
72 	struct strimpl l;	/* local symbols */
73 	struct strimpl g;	/* global symbols */
74 };
75 
76 static int	is_debug_symbol(unsigned char st_info);
77 static int	is_global_symbol(unsigned char st_info);
78 static int	is_local_symbol(unsigned char st_info);
79 static int	is_local_label(const char *name);
80 static int	is_needed_symbol(struct elfcopy *ecp, int i, GElf_Sym *s);
81 static int	is_remove_symbol(struct elfcopy *ecp, size_t sc, int i,
82 		    GElf_Sym *s, const char *name);
83 static int	is_weak_symbol(unsigned char st_info);
84 static int	lookup_exact_string(hash_head *hash, const char *buf,
85 		    const char *s);
86 static int	generate_symbols(struct elfcopy *ecp);
87 static void	mark_reloc_symbols(struct elfcopy *ecp, size_t sc);
88 static void	mark_section_group_symbols(struct elfcopy *ecp, size_t sc);
89 uint32_t	str_hash(const char *s);
90 
91 /* Convenient bit vector operation macros. */
92 #define BIT_SET(v, n) (v[(n)>>3] |= 1U << ((n) & 7))
93 #define BIT_CLR(v, n) (v[(n)>>3] &= ~(1U << ((n) & 7)))
94 #define BIT_ISSET(v, n) (v[(n)>>3] & (1U << ((n) & 7)))
95 
96 static int
97 is_debug_symbol(unsigned char st_info)
98 {
99 
100 	if (GELF_ST_TYPE(st_info) == STT_SECTION ||
101 	    GELF_ST_TYPE(st_info) == STT_FILE)
102 		return (1);
103 
104 	return (0);
105 }
106 
107 static int
108 is_global_symbol(unsigned char st_info)
109 {
110 
111 	if (GELF_ST_BIND(st_info) == STB_GLOBAL ||
112 	    GELF_ST_BIND(st_info) == STB_GNU_UNIQUE)
113 		return (1);
114 
115 	return (0);
116 }
117 
118 static int
119 is_weak_symbol(unsigned char st_info)
120 {
121 
122 	if (GELF_ST_BIND(st_info) == STB_WEAK)
123 		return (1);
124 
125 	return (0);
126 }
127 
128 static int
129 is_local_symbol(unsigned char st_info)
130 {
131 
132 	if (GELF_ST_BIND(st_info) == STB_LOCAL)
133 		return (1);
134 
135 	return (0);
136 }
137 
138 static int
139 is_hidden_symbol(unsigned char st_other)
140 {
141 
142 	if (GELF_ST_VISIBILITY(st_other) == STV_HIDDEN ||
143 	    GELF_ST_VISIBILITY(st_other) == STV_INTERNAL)
144 		return (1);
145 
146 	return (0);
147 }
148 
149 static int
150 is_local_label(const char *name)
151 {
152 
153 	/* Compiler generated local symbols that start with .L */
154 	if (name[0] == '.' && name[1] == 'L')
155 		return (1);
156 
157 	return (0);
158 }
159 
160 /*
161  * Symbols related to relocation are needed.
162  */
163 static int
164 is_needed_symbol(struct elfcopy *ecp, int i, GElf_Sym *s)
165 {
166 
167 	/* If symbol involves relocation, it is needed. */
168 	if (BIT_ISSET(ecp->v_rel, i))
169 		return (1);
170 
171 	/* Symbols referred by COMDAT sections are needed. */
172 	if (BIT_ISSET(ecp->v_grp, i))
173 		return (1);
174 
175 	/*
176 	 * For relocatable files (.o files), global and weak symbols
177 	 * are needed.
178 	 */
179 	if (ecp->flags & RELOCATABLE) {
180 		if (is_global_symbol(s->st_info) || is_weak_symbol(s->st_info))
181 			return (1);
182 	}
183 
184 	return (0);
185 }
186 
187 static int
188 is_remove_symbol(struct elfcopy *ecp, size_t sc, int i, GElf_Sym *s,
189     const char *name)
190 {
191 	GElf_Sym sym0 = {
192 		0, 		/* st_name */
193 		0,		/* st_value */
194 		0,		/* st_size */
195 		0,		/* st_info */
196 		0,		/* st_other */
197 		SHN_UNDEF,	/* st_shndx */
198 	};
199 
200 	/*
201 	 * Keep the first symbol if it is the special reserved symbol.
202 	 * XXX Should we generate one if it's missing?
203 	 */
204 	if (i == 0 && !memcmp(s, &sym0, sizeof(GElf_Sym)))
205 		return (0);
206 
207 	/* Remove the symbol if the section it refers to was removed. */
208 	if (s->st_shndx != SHN_UNDEF && s->st_shndx < SHN_LORESERVE &&
209 	    ecp->secndx[s->st_shndx] == 0)
210 		return (1);
211 
212 	/* Keep the symbol if specified by command line option -K. */
213 	if (lookup_symop_list(ecp, name, SYMOP_KEEP) != NULL)
214 		return (0);
215 
216 	if (ecp->strip == STRIP_ALL)
217 		return (1);
218 
219 	/* Mark symbols used in relocation. */
220 	if (ecp->v_rel == NULL)
221 		mark_reloc_symbols(ecp, sc);
222 
223 	/* Mark symbols used in section groups. */
224 	if (ecp->v_grp == NULL)
225 		mark_section_group_symbols(ecp, sc);
226 
227 	/*
228 	 * Strip the symbol if specified by command line option -N,
229 	 * unless it's used in relocation.
230 	 */
231 	if (lookup_symop_list(ecp, name, SYMOP_STRIP) != NULL) {
232 		if (BIT_ISSET(ecp->v_rel, i)) {
233 			warnx("not stripping symbol `%s' because it is named"
234 			    " in a relocation", name);
235 			return (0);
236 		}
237 		return (1);
238 	}
239 
240 	if (is_needed_symbol(ecp, i, s))
241 		return (0);
242 
243 	if (ecp->strip == STRIP_UNNEEDED)
244 		return (1);
245 
246 	if ((ecp->flags & DISCARD_LOCAL) && is_local_symbol(s->st_info) &&
247 	    !is_debug_symbol(s->st_info))
248 		return (1);
249 
250 	if ((ecp->flags & DISCARD_LLABEL) && is_local_symbol(s->st_info) &&
251 	    !is_debug_symbol(s->st_info) && is_local_label(name))
252 		return (1);
253 
254 	if (ecp->strip == STRIP_DEBUG && is_debug_symbol(s->st_info))
255 		return (1);
256 
257 	return (0);
258 }
259 
260 /*
261  * Mark symbols referred by relocation entries.
262  */
263 static void
264 mark_reloc_symbols(struct elfcopy *ecp, size_t sc)
265 {
266 	const char	*name;
267 	Elf_Data	*d;
268 	Elf_Scn		*s;
269 	GElf_Rel	 r;
270 	GElf_Rela	 ra;
271 	GElf_Shdr	 sh;
272 	size_t		 n, indx;
273 	int		 elferr, i, len;
274 
275 	ecp->v_rel = calloc((sc + 7) / 8, 1);
276 	if (ecp->v_rel == NULL)
277 		err(EXIT_FAILURE, "calloc failed");
278 
279 	if (elf_getshstrndx(ecp->ein, &indx) == 0)
280 		errx(EXIT_FAILURE, "elf_getshstrndx failed: %s",
281 		    elf_errmsg(-1));
282 
283 	s = NULL;
284 	while ((s = elf_nextscn(ecp->ein, s)) != NULL) {
285 		if (gelf_getshdr(s, &sh) != &sh)
286 			errx(EXIT_FAILURE, "elf_getshdr failed: %s",
287 			    elf_errmsg(-1));
288 
289 		if (sh.sh_type != SHT_REL && sh.sh_type != SHT_RELA)
290 			continue;
291 
292 		/*
293 		 * Skip if this reloc section won't appear in the
294 		 * output object.
295 		 */
296 		if ((name = elf_strptr(ecp->ein, indx, sh.sh_name)) == NULL)
297 			errx(EXIT_FAILURE, "elf_strptr failed: %s",
298 			    elf_errmsg(-1));
299 		if (is_remove_section(ecp, name) ||
300 		    is_remove_reloc_sec(ecp, sh.sh_info))
301 			continue;
302 
303 		/* Skip if it's not for .symtab */
304 		if (sh.sh_link != elf_ndxscn(ecp->symtab->is))
305 			continue;
306 
307 		d = NULL;
308 		n = 0;
309 		while (n < sh.sh_size && (d = elf_getdata(s, d)) != NULL) {
310 			len = d->d_size / sh.sh_entsize;
311 			for (i = 0; i < len; i++) {
312 				if (sh.sh_type == SHT_REL) {
313 					if (gelf_getrel(d, i, &r) != &r)
314 						errx(EXIT_FAILURE,
315 						    "elf_getrel failed: %s",
316 						     elf_errmsg(-1));
317 					n = GELF_R_SYM(r.r_info);
318 				} else {
319 					if (gelf_getrela(d, i, &ra) != &ra)
320 						errx(EXIT_FAILURE,
321 						    "elf_getrela failed: %s",
322 						     elf_errmsg(-1));
323 					n = GELF_R_SYM(ra.r_info);
324 				}
325 				if (n > 0 && n < sc)
326 					BIT_SET(ecp->v_rel, n);
327 				else if (n != 0)
328 					warnx("invalid symbox index");
329 			}
330 		}
331 		elferr = elf_errno();
332 		if (elferr != 0)
333 			errx(EXIT_FAILURE, "elf_getdata failed: %s",
334 			    elf_errmsg(elferr));
335 	}
336 	elferr = elf_errno();
337 	if (elferr != 0)
338 		errx(EXIT_FAILURE, "elf_nextscn failed: %s",
339 		    elf_errmsg(elferr));
340 }
341 
342 static void
343 mark_section_group_symbols(struct elfcopy *ecp, size_t sc)
344 {
345 	const char	*name;
346 	Elf_Scn		*s;
347 	GElf_Shdr	 sh;
348 	size_t		 indx;
349 	int		 elferr;
350 
351 	ecp->v_grp = calloc((sc + 7) / 8, 1);
352 	if (ecp->v_grp == NULL)
353 		err(EXIT_FAILURE, "calloc failed");
354 
355 	if (elf_getshstrndx(ecp->ein, &indx) == 0)
356 		errx(EXIT_FAILURE, "elf_getshstrndx failed: %s",
357 		    elf_errmsg(-1));
358 
359 	s = NULL;
360 	while ((s = elf_nextscn(ecp->ein, s)) != NULL) {
361 		if (gelf_getshdr(s, &sh) != &sh)
362 			errx(EXIT_FAILURE, "elf_getshdr failed: %s",
363 			    elf_errmsg(-1));
364 
365 		if (sh.sh_type != SHT_GROUP)
366 			continue;
367 
368 		if ((name = elf_strptr(ecp->ein, indx, sh.sh_name)) == NULL)
369 			errx(EXIT_FAILURE, "elf_strptr failed: %s",
370 			    elf_errmsg(-1));
371 		if (is_remove_section(ecp, name))
372 			continue;
373 
374 		if (sh.sh_info > 0 && sh.sh_info < sc)
375 			BIT_SET(ecp->v_grp, sh.sh_info);
376 		else if (sh.sh_info != 0)
377 			warnx("invalid symbox index");
378 	}
379 	elferr = elf_errno();
380 	if (elferr != 0)
381 		errx(EXIT_FAILURE, "elf_nextscn failed: %s",
382 		    elf_errmsg(elferr));
383 }
384 
385 static int
386 generate_symbols(struct elfcopy *ecp)
387 {
388 	struct section	*s;
389 	struct symop	*sp;
390 	struct symbuf	*sy_buf;
391 	struct strbuf	*st_buf;
392 	const char	*name;
393 	char		*newname;
394 	unsigned char	*gsym;
395 	GElf_Shdr	 ish;
396 	GElf_Sym	 sym;
397 	Elf_Data*	 id;
398 	Elf_Scn		*is;
399 	size_t		 ishstrndx, namelen, ndx, sc, symndx;
400 	int		 ec, elferr, i;
401 
402 	if (elf_getshstrndx(ecp->ein, &ishstrndx) == 0)
403 		errx(EXIT_FAILURE, "elf_getshstrndx failed: %s",
404 		    elf_errmsg(-1));
405 	if ((ec = gelf_getclass(ecp->eout)) == ELFCLASSNONE)
406 		errx(EXIT_FAILURE, "gelf_getclass failed: %s",
407 		    elf_errmsg(-1));
408 
409 	/* Create buffers for .symtab and .strtab. */
410 	if ((sy_buf = calloc(1, sizeof(*sy_buf))) == NULL)
411 		err(EXIT_FAILURE, "calloc failed");
412 	if ((st_buf = calloc(1, sizeof(*st_buf))) == NULL)
413 		err(EXIT_FAILURE, "calloc failed");
414 	sy_buf->gcap = sy_buf->lcap = 64;
415 	st_buf->g.cap = 256;
416 	st_buf->l.cap = 64;
417 	st_buf->l.sz = 1;	/* '\0' at start. */
418 	st_buf->g.sz = 0;
419 
420 	ecp->symtab->sz = 0;
421 	ecp->strtab->sz = 0;
422 	ecp->symtab->buf = sy_buf;
423 	ecp->strtab->buf = st_buf;
424 
425 	gsym = NULL;
426 
427 	/*
428 	 * Create bit vector v_secsym, which is used to mark sections
429 	 * that already have corresponding STT_SECTION symbols.
430 	 */
431 	ecp->v_secsym = calloc((ecp->nos + 7) / 8, 1);
432 	if (ecp->v_secsym == NULL)
433 		err(EXIT_FAILURE, "calloc failed");
434 
435 	/* Locate .strtab of input object. */
436 	symndx = 0;
437 	name = NULL;
438 	is = NULL;
439 	while ((is = elf_nextscn(ecp->ein, is)) != NULL) {
440 		if (gelf_getshdr(is, &ish) != &ish)
441 			errx(EXIT_FAILURE, "elf_getshdr failed: %s",
442 			    elf_errmsg(-1));
443 		if ((name = elf_strptr(ecp->ein, ishstrndx, ish.sh_name)) ==
444 		    NULL)
445 			errx(EXIT_FAILURE, "elf_strptr failed: %s",
446 			    elf_errmsg(-1));
447 		if (strcmp(name, ".strtab") == 0) {
448 			symndx = elf_ndxscn(is);
449 			break;
450 		}
451 	}
452 	elferr = elf_errno();
453 	if (elferr != 0)
454 		errx(EXIT_FAILURE, "elf_nextscn failed: %s",
455 		    elf_errmsg(elferr));
456 
457 	/* Symbol table should exist if this function is called. */
458 	if (symndx == 0) {
459 		warnx("can't find .strtab section");
460 		goto clean;
461 	}
462 
463 	/* Locate .symtab of input object. */
464 	is = NULL;
465 	while ((is = elf_nextscn(ecp->ein, is)) != NULL) {
466 		if (gelf_getshdr(is, &ish) != &ish)
467 			errx(EXIT_FAILURE, "elf_getshdr failed: %s",
468 			    elf_errmsg(-1));
469 		if ((name = elf_strptr(ecp->ein, ishstrndx, ish.sh_name)) ==
470 		    NULL)
471 			errx(EXIT_FAILURE, "elf_strptr failed: %s",
472 			    elf_errmsg(-1));
473 		if (strcmp(name, ".symtab") == 0)
474 			break;
475 	}
476 	elferr = elf_errno();
477 	if (elferr != 0)
478 		errx(EXIT_FAILURE, "elf_nextscn failed: %s",
479 		    elf_errmsg(elferr));
480 	if (is == NULL)
481 		errx(EXIT_FAILURE, "can't find .strtab section");
482 
483 	/*
484 	 * Create bit vector gsym to mark global symbols, and symndx
485 	 * to keep track of symbol index changes from input object to
486 	 * output object, it is used by update_reloc() later to update
487 	 * relocation information.
488 	 */
489 	sc = ish.sh_size / ish.sh_entsize;
490 	if (sc > 0) {
491 		ecp->symndx = calloc(sc, sizeof(*ecp->symndx));
492 		if (ecp->symndx == NULL)
493 			err(EXIT_FAILURE, "calloc failed");
494 		gsym = calloc((sc + 7) / 8, sizeof(*gsym));
495 		if (gsym == NULL)
496 			err(EXIT_FAILURE, "calloc failed");
497 		if ((id = elf_getdata(is, NULL)) == NULL) {
498 			elferr = elf_errno();
499 			if (elferr != 0)
500 				errx(EXIT_FAILURE, "elf_getdata failed: %s",
501 				    elf_errmsg(elferr));
502 			goto clean;
503 		}
504 	} else
505 		return (0);
506 
507 	/* Copy/Filter each symbol. */
508 	for (i = 0; (size_t)i < sc; i++) {
509 		if (gelf_getsym(id, i, &sym) != &sym)
510 			errx(EXIT_FAILURE, "gelf_getsym failed: %s",
511 			    elf_errmsg(-1));
512 		if ((name = elf_strptr(ecp->ein, symndx, sym.st_name)) == NULL)
513 			errx(EXIT_FAILURE, "elf_strptr failed: %s",
514 			    elf_errmsg(-1));
515 
516 		/* Symbol filtering. */
517 		if (is_remove_symbol(ecp, sc, i, &sym, name) != 0)
518 			continue;
519 
520 		/* Check if we need to change the binding of this symbol. */
521 		if (is_global_symbol(sym.st_info) ||
522 		    is_weak_symbol(sym.st_info)) {
523 			/*
524 			 * XXX Binutils objcopy does not weaken certain
525 			 * symbols.
526 			 */
527 			if (ecp->flags & WEAKEN_ALL ||
528 			    lookup_symop_list(ecp, name, SYMOP_WEAKEN) != NULL)
529 				sym.st_info = GELF_ST_INFO(STB_WEAK,
530 				    GELF_ST_TYPE(sym.st_info));
531 			/* Do not localize undefined symbols. */
532 			if (sym.st_shndx != SHN_UNDEF &&
533 			    lookup_symop_list(ecp, name, SYMOP_LOCALIZE) !=
534 			    NULL)
535 				sym.st_info = GELF_ST_INFO(STB_LOCAL,
536 				    GELF_ST_TYPE(sym.st_info));
537 			if (ecp->flags & KEEP_GLOBAL &&
538 			    sym.st_shndx != SHN_UNDEF &&
539 			    lookup_symop_list(ecp, name, SYMOP_KEEPG) == NULL)
540 				sym.st_info = GELF_ST_INFO(STB_LOCAL,
541 				    GELF_ST_TYPE(sym.st_info));
542 			if (ecp->flags & LOCALIZE_HIDDEN &&
543 			    sym.st_shndx != SHN_UNDEF &&
544 			    is_hidden_symbol(sym.st_other))
545 				sym.st_info = GELF_ST_INFO(STB_LOCAL,
546 				    GELF_ST_TYPE(sym.st_info));
547 		} else {
548 			/* STB_LOCAL binding. */
549 			if (lookup_symop_list(ecp, name, SYMOP_GLOBALIZE) !=
550 			    NULL)
551 				sym.st_info = GELF_ST_INFO(STB_GLOBAL,
552 				    GELF_ST_TYPE(sym.st_info));
553 			/* XXX We should globalize weak symbol? */
554 		}
555 
556 		/* Check if we need to rename this symbol. */
557 		if ((sp = lookup_symop_list(ecp, name, SYMOP_REDEF)) != NULL)
558 			name = sp->newname;
559 
560 		/* Check if we need to prefix the symbols. */
561 		newname = NULL;
562 		if (ecp->prefix_sym != NULL && name != NULL && *name != '\0') {
563 			namelen = strlen(name) + strlen(ecp->prefix_sym) + 1;
564 			if ((newname = malloc(namelen)) == NULL)
565 				err(EXIT_FAILURE, "malloc failed");
566 			snprintf(newname, namelen, "%s%s", ecp->prefix_sym,
567 			    name);
568 			name = newname;
569 		}
570 
571 		/* Copy symbol, mark global/weak symbol and add to index map. */
572 		if (is_global_symbol(sym.st_info) ||
573 		    is_weak_symbol(sym.st_info)) {
574 			BIT_SET(gsym, i);
575 			ecp->symndx[i] = sy_buf->ngs;
576 		} else
577 			ecp->symndx[i] = sy_buf->nls;
578 		add_to_symtab(ecp, name, sym.st_value, sym.st_size,
579 		    sym.st_shndx, sym.st_info, sym.st_other, 0);
580 
581 		if (newname != NULL)
582 			free(newname);
583 
584 		/*
585 		 * If the symbol is a STT_SECTION symbol, mark the section
586 		 * it points to.
587 		 */
588 		if (GELF_ST_TYPE(sym.st_info) == STT_SECTION &&
589 		    sym.st_shndx < SHN_LORESERVE) {
590 			assert(ecp->secndx[sym.st_shndx] < (uint64_t)ecp->nos);
591 			BIT_SET(ecp->v_secsym, ecp->secndx[sym.st_shndx]);
592 		}
593 	}
594 
595 	/*
596 	 * Give up if there is no real symbols inside the table.
597 	 * XXX The logic here needs to be improved. We need to
598 	 * check if that only local symbol is the reserved symbol.
599 	 */
600 	if (sy_buf->nls <= 1 && sy_buf->ngs == 0)
601 		goto clean;
602 
603 	/*
604 	 * Create STT_SECTION symbols for sections that do not already
605 	 * got one. However, we do not create STT_SECTION symbol for
606 	 * .symtab, .strtab, .shstrtab and reloc sec of relocatables.
607 	 */
608 	TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
609 		if (s->pseudo)
610 			continue;
611 		if (strcmp(s->name, ".symtab") == 0 ||
612 		    strcmp(s->name, ".strtab") == 0 ||
613 		    strcmp(s->name, ".shstrtab") == 0)
614 			continue;
615 		if ((ecp->flags & RELOCATABLE) != 0 &&
616 		    ((s->type == SHT_REL) || (s->type == SHT_RELA)))
617 			continue;
618 
619 		if ((ndx = elf_ndxscn(s->os)) == SHN_UNDEF)
620 			errx(EXIT_FAILURE, "elf_ndxscn failed: %s",
621 			    elf_errmsg(-1));
622 
623 		if (!BIT_ISSET(ecp->v_secsym, ndx)) {
624 			sym.st_name  = 0;
625 			sym.st_value = s->vma;
626 			sym.st_size  = 0;
627 			sym.st_info  = GELF_ST_INFO(STB_LOCAL, STT_SECTION);
628 			sym.st_other = STV_DEFAULT;
629 			/*
630 			 * Don't let add_to_symtab() touch sym.st_shndx.
631 			 * In this case, we know the index already.
632 			 */
633 			add_to_symtab(ecp, NULL, sym.st_value, sym.st_size,
634 			    ndx, sym.st_info, sym.st_other, 1);
635 		}
636 	}
637 
638 	/*
639 	 * Update st_name and index map for global/weak symbols. Note that
640 	 * global/weak symbols are put after local symbols.
641 	 */
642 	if (gsym != NULL) {
643 		for(i = 0; (size_t) i < sc; i++) {
644 			if (!BIT_ISSET(gsym, i))
645 				continue;
646 
647 			/* Update st_name. */
648 			if (ec == ELFCLASS32)
649 				sy_buf->g32[ecp->symndx[i]].st_name +=
650 				    st_buf->l.sz;
651 			else
652 				sy_buf->g64[ecp->symndx[i]].st_name +=
653 				    st_buf->l.sz;
654 
655 			/* Update index map. */
656 			ecp->symndx[i] += sy_buf->nls;
657 		}
658 		free(gsym);
659 	}
660 
661 	return (1);
662 
663 clean:
664 	free(gsym);
665 	free_symtab(ecp);
666 
667 	return (0);
668 }
669 
670 void
671 create_symtab(struct elfcopy *ecp)
672 {
673 	struct section	*s, *sy, *st;
674 	size_t		 maxndx, ndx;
675 
676 	sy = ecp->symtab;
677 	st = ecp->strtab;
678 
679 	assert(sy != NULL && st != NULL);
680 
681 	/*
682 	 * Set section index map for .symtab and .strtab. We need to set
683 	 * these map because otherwise symbols which refer to .symtab and
684 	 * .strtab will be removed by symbol filtering unconditionally.
685 	 * And we have to figure out scn index this way (instead of calling
686 	 * elf_ndxscn) because we can not create Elf_Scn before we're certain
687 	 * that .symtab and .strtab will exist in the output object.
688 	 */
689 	maxndx = 0;
690 	TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
691 		if (s->os == NULL)
692 			continue;
693 		if ((ndx = elf_ndxscn(s->os)) == SHN_UNDEF)
694 			errx(EXIT_FAILURE, "elf_ndxscn failed: %s",
695 			    elf_errmsg(-1));
696 		if (ndx > maxndx)
697 			maxndx = ndx;
698 	}
699 	ecp->secndx[elf_ndxscn(sy->is)] = maxndx + 1;
700 	ecp->secndx[elf_ndxscn(st->is)] = maxndx + 2;
701 
702 	/*
703 	 * Generate symbols for output object if SYMTAB_INTACT is not set.
704 	 * If there is no symbol in the input object or all the symbols are
705 	 * stripped, then free all the resouces allotted for symbol table,
706 	 * and clear SYMTAB_EXIST flag.
707 	 */
708 	if (((ecp->flags & SYMTAB_INTACT) == 0) && !generate_symbols(ecp)) {
709 		TAILQ_REMOVE(&ecp->v_sec, ecp->symtab, sec_list);
710 		TAILQ_REMOVE(&ecp->v_sec, ecp->strtab, sec_list);
711 		free(ecp->symtab->buf);
712 		free(ecp->symtab);
713 		free(ecp->strtab->buf);
714 		free(ecp->strtab);
715 		ecp->symtab = NULL;
716 		ecp->strtab = NULL;
717 		ecp->flags &= ~SYMTAB_EXIST;
718 		return;
719 	}
720 
721 	/* Create output Elf_Scn for .symtab and .strtab. */
722 	if ((sy->os = elf_newscn(ecp->eout)) == NULL ||
723 	    (st->os = elf_newscn(ecp->eout)) == NULL)
724 		errx(EXIT_FAILURE, "elf_newscn failed: %s",
725 		    elf_errmsg(-1));
726 	/* Update secndx anyway. */
727 	ecp->secndx[elf_ndxscn(sy->is)] = elf_ndxscn(sy->os);
728 	ecp->secndx[elf_ndxscn(st->is)] = elf_ndxscn(st->os);
729 
730 	/*
731 	 * Copy .symtab and .strtab section headers from input to output
732 	 * object to start with, these will be overridden later if need.
733 	 */
734 	copy_shdr(ecp, sy, ".symtab", 1, 0);
735 	copy_shdr(ecp, st, ".strtab", 1, 0);
736 
737 	/* Copy verbatim if symbol table is intact. */
738 	if (ecp->flags & SYMTAB_INTACT) {
739 		copy_data(sy);
740 		copy_data(st);
741 		return;
742 	}
743 
744 	create_symtab_data(ecp);
745 }
746 
747 void
748 free_symtab(struct elfcopy *ecp)
749 {
750 	struct symbuf	*sy_buf;
751 	struct strbuf	*st_buf;
752 	struct sthash	*sh, *shtmp;
753 	int i;
754 
755 	if (ecp->symtab != NULL && ecp->symtab->buf != NULL) {
756 		sy_buf = ecp->symtab->buf;
757 		if (sy_buf->l32 != NULL)
758 			free(sy_buf->l32);
759 		if (sy_buf->g32 != NULL)
760 			free(sy_buf->g32);
761 		if (sy_buf->l64 != NULL)
762 			free(sy_buf->l64);
763 		if (sy_buf->g64 != NULL)
764 			free(sy_buf->g64);
765 	}
766 
767 	if (ecp->strtab != NULL && ecp->strtab->buf != NULL) {
768 		st_buf = ecp->strtab->buf;
769 		if (st_buf->l.buf != NULL)
770 			free(st_buf->l.buf);
771 		if (st_buf->g.buf != NULL)
772 			free(st_buf->g.buf);
773 		for (i = 0; i < STHASHSIZE; i++) {
774 			LIST_FOREACH_SAFE(sh, &st_buf->l.hash[i], sh_next,
775 			    shtmp) {
776 				LIST_REMOVE(sh, sh_next);
777 				free(sh);
778 			}
779 			LIST_FOREACH_SAFE(sh, &st_buf->g.hash[i], sh_next,
780 			    shtmp) {
781 				LIST_REMOVE(sh, sh_next);
782 				free(sh);
783 			}
784 		}
785 	}
786 
787 	if (ecp->symndx != NULL) {
788 		free(ecp->symndx);
789 		ecp->symndx = NULL;
790 	}
791 	if (ecp->v_rel != NULL) {
792 		free(ecp->v_rel);
793 		ecp->v_rel = NULL;
794 	}
795 	if (ecp->v_grp != NULL) {
796 		free(ecp->v_grp);
797 		ecp->v_grp = NULL;
798 	}
799 	if (ecp->v_secsym != NULL) {
800 		free(ecp->v_secsym);
801 		ecp->v_secsym = NULL;
802 	}
803 }
804 
805 void
806 create_external_symtab(struct elfcopy *ecp)
807 {
808 	struct section *s;
809 	struct symbuf *sy_buf;
810 	struct strbuf *st_buf;
811 	GElf_Shdr sh;
812 	size_t ndx;
813 
814 	if (ecp->oec == ELFCLASS32)
815 		ecp->symtab = create_external_section(ecp, ".symtab", NULL,
816 		    NULL, 0, 0, SHT_SYMTAB, ELF_T_SYM, 0, 4, 0, 0);
817 	else
818 		ecp->symtab = create_external_section(ecp, ".symtab", NULL,
819 		    NULL, 0, 0, SHT_SYMTAB, ELF_T_SYM, 0, 8, 0, 0);
820 
821 	ecp->strtab = create_external_section(ecp, ".strtab", NULL, NULL, 0, 0,
822 	    SHT_STRTAB, ELF_T_BYTE, 0, 1, 0, 0);
823 
824 	/* Let sh_link field of .symtab section point to .strtab section. */
825 	if (gelf_getshdr(ecp->symtab->os, &sh) == NULL)
826 		errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
827 		    elf_errmsg(-1));
828 	sh.sh_link = elf_ndxscn(ecp->strtab->os);
829 	if (!gelf_update_shdr(ecp->symtab->os, &sh))
830 		errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
831 		    elf_errmsg(-1));
832 
833 	/* Create buffers for .symtab and .strtab. */
834 	if ((sy_buf = calloc(1, sizeof(*sy_buf))) == NULL)
835 		err(EXIT_FAILURE, "calloc failed");
836 	if ((st_buf = calloc(1, sizeof(*st_buf))) == NULL)
837 		err(EXIT_FAILURE, "calloc failed");
838 	sy_buf->gcap = sy_buf->lcap = 64;
839 	st_buf->g.cap = 256;
840 	st_buf->l.cap = 64;
841 	st_buf->l.sz = 1;	/* '\0' at start. */
842 	st_buf->g.sz = 0;
843 
844 	ecp->symtab->sz = 0;
845 	ecp->strtab->sz = 0;
846 	ecp->symtab->buf = sy_buf;
847 	ecp->strtab->buf = st_buf;
848 
849 	/* Always create the special symbol at the symtab beginning. */
850 	add_to_symtab(ecp, NULL, 0, 0, SHN_UNDEF,
851 	    ELF32_ST_INFO(STB_LOCAL, STT_NOTYPE), 0, 1);
852 
853 	/* Create STT_SECTION symbols. */
854 	TAILQ_FOREACH(s, &ecp->v_sec, sec_list) {
855 		if (s->pseudo)
856 			continue;
857 		if (strcmp(s->name, ".symtab") == 0 ||
858 		    strcmp(s->name, ".strtab") == 0 ||
859 		    strcmp(s->name, ".shstrtab") == 0)
860 			continue;
861 		(void) elf_errno();
862 		if ((ndx = elf_ndxscn(s->os)) == SHN_UNDEF) {
863 			warnx("elf_ndxscn failed: %s",
864 			    elf_errmsg(-1));
865 			continue;
866 		}
867 		add_to_symtab(ecp, NULL, 0, 0, ndx,
868 		    GELF_ST_INFO(STB_LOCAL, STT_SECTION), 0, 1);
869 	}
870 }
871 
872 void
873 add_to_symtab(struct elfcopy *ecp, const char *name, uint64_t st_value,
874     uint64_t st_size, uint16_t st_shndx, unsigned char st_info,
875     unsigned char st_other, int ndx_known)
876 {
877 	struct symbuf *sy_buf;
878 	struct strbuf *st_buf;
879 	struct sthash *sh;
880 	uint32_t hash;
881 	int pos;
882 
883 	/*
884 	 * Convenient macro for copying global/local 32/64 bit symbols
885 	 * from input object to the buffer created for output object.
886 	 * It handles buffer growing, st_name calculating and st_shndx
887 	 * updating for symbols with non-special section index.
888 	 */
889 #define	_ST_NAME_EMPTY_l 0
890 #define	_ST_NAME_EMPTY_g -1
891 #define	_ADDSYM(B, SZ) do {						\
892 	if (sy_buf->B##SZ == NULL) {					\
893 		sy_buf->B##SZ = malloc(sy_buf->B##cap *			\
894 		    sizeof(Elf##SZ##_Sym));				\
895 		if (sy_buf->B##SZ == NULL)				\
896 			err(EXIT_FAILURE, "malloc failed");		\
897 	} else if (sy_buf->n##B##s >= sy_buf->B##cap) {			\
898 		sy_buf->B##cap *= 2;					\
899 		sy_buf->B##SZ = realloc(sy_buf->B##SZ, sy_buf->B##cap *	\
900 		    sizeof(Elf##SZ##_Sym));				\
901 		if (sy_buf->B##SZ == NULL)				\
902 			err(EXIT_FAILURE, "realloc failed");		\
903 	}								\
904 	sy_buf->B##SZ[sy_buf->n##B##s].st_info	= st_info;		\
905 	sy_buf->B##SZ[sy_buf->n##B##s].st_other	= st_other;		\
906 	sy_buf->B##SZ[sy_buf->n##B##s].st_value	= st_value;		\
907 	sy_buf->B##SZ[sy_buf->n##B##s].st_size	= st_size;		\
908 	if (ndx_known)							\
909 		sy_buf->B##SZ[sy_buf->n##B##s].st_shndx = st_shndx;	\
910 	else if (st_shndx == SHN_UNDEF || st_shndx >= SHN_LORESERVE)	\
911 		sy_buf->B##SZ[sy_buf->n##B##s].st_shndx = st_shndx;	\
912 	else								\
913 		sy_buf->B##SZ[sy_buf->n##B##s].st_shndx	=		\
914 			ecp->secndx[st_shndx];				\
915 	if (st_buf->B.buf == NULL) {					\
916 		st_buf->B.buf = calloc(st_buf->B.cap,			\
917 		    sizeof(*st_buf->B.buf));				\
918 		if (st_buf->B.buf == NULL)				\
919 			err(EXIT_FAILURE, "malloc failed");		\
920 	}								\
921 	if (name != NULL && *name != '\0') {				\
922 		pos = lookup_exact_string(st_buf->B.hash, st_buf->B.buf,\
923 		    name);						\
924 		if (pos != -1)						\
925 			sy_buf->B##SZ[sy_buf->n##B##s].st_name = pos;	\
926 		else {							\
927 			sy_buf->B##SZ[sy_buf->n##B##s].st_name =	\
928 			    st_buf->B.sz;				\
929 			while (st_buf->B.sz + strlen(name) >=		\
930 			    st_buf->B.cap - 1) {			\
931 				st_buf->B.cap *= 2;			\
932 				st_buf->B.buf = realloc(st_buf->B.buf,	\
933 				    st_buf->B.cap);			\
934 				if (st_buf->B.buf == NULL)		\
935 					err(EXIT_FAILURE,		\
936 					    "realloc failed");		\
937 			}						\
938 			if ((sh = malloc(sizeof(*sh))) == NULL)		\
939 				err(EXIT_FAILURE, "malloc failed");	\
940 			sh->sh_off = st_buf->B.sz;			\
941 			hash = str_hash(name);				\
942 			LIST_INSERT_HEAD(&st_buf->B.hash[hash], sh,	\
943 			    sh_next);					\
944 			strncpy(&st_buf->B.buf[st_buf->B.sz], name,	\
945 			    strlen(name));				\
946 			st_buf->B.buf[st_buf->B.sz + strlen(name)] = '\0'; \
947 			st_buf->B.sz += strlen(name) + 1;		\
948 		}							\
949 	} else								\
950 		sy_buf->B##SZ[sy_buf->n##B##s].st_name = 		\
951 		    (Elf##SZ##_Word)_ST_NAME_EMPTY_##B;			\
952 	sy_buf->n##B##s++;						\
953 } while (0)
954 
955 	sy_buf = ecp->symtab->buf;
956 	st_buf = ecp->strtab->buf;
957 
958 	if (ecp->oec == ELFCLASS32) {
959 		if (is_local_symbol(st_info))
960 			_ADDSYM(l, 32);
961 		else
962 			_ADDSYM(g, 32);
963 	} else {
964 		if (is_local_symbol(st_info))
965 			_ADDSYM(l, 64);
966 		else
967 			_ADDSYM(g, 64);
968 	}
969 
970 	/* Update section size. */
971 	ecp->symtab->sz = (sy_buf->nls + sy_buf->ngs) *
972 	    (ecp->oec == ELFCLASS32 ? sizeof(Elf32_Sym) : sizeof(Elf64_Sym));
973 	ecp->strtab->sz = st_buf->l.sz + st_buf->g.sz;
974 
975 #undef	_ADDSYM
976 #undef	_ST_NAME_EMPTY_l
977 #undef	_ST_NAME_EMPTY_g
978 }
979 
980 void
981 finalize_external_symtab(struct elfcopy *ecp)
982 {
983 	struct symbuf *sy_buf;
984 	struct strbuf *st_buf;
985 	int i;
986 
987 	/*
988 	 * Update st_name for global/weak symbols. (global/weak symbols
989 	 * are put after local symbols)
990 	 */
991 	sy_buf = ecp->symtab->buf;
992 	st_buf = ecp->strtab->buf;
993 	for (i = 0; (size_t) i < sy_buf->ngs; i++) {
994 		if (ecp->oec == ELFCLASS32) {
995 			if (sy_buf->g32[i].st_name == (Elf32_Word)-1)
996 				sy_buf->g32[i].st_name = 0;
997 			else
998 				sy_buf->g32[i].st_name += st_buf->l.sz;
999 		} else {
1000 			if (sy_buf->g64[i].st_name == (Elf64_Word)-1)
1001 				sy_buf->g64[i].st_name = 0;
1002 			else
1003 				sy_buf->g64[i].st_name += st_buf->l.sz;
1004 		}
1005 	}
1006 }
1007 
1008 void
1009 create_symtab_data(struct elfcopy *ecp)
1010 {
1011 	struct section	*sy, *st;
1012 	struct symbuf	*sy_buf;
1013 	struct strbuf	*st_buf;
1014 	Elf_Data	*gsydata, *lsydata, *gstdata, *lstdata;
1015 	GElf_Shdr	 shy, sht;
1016 
1017 	sy = ecp->symtab;
1018 	st = ecp->strtab;
1019 
1020 	if (gelf_getshdr(sy->os, &shy) == NULL)
1021 		errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1022 		    elf_errmsg(-1));
1023 	if (gelf_getshdr(st->os, &sht) == NULL)
1024 		errx(EXIT_FAILURE, "gelf_getshdr() failed: %s",
1025 		    elf_errmsg(-1));
1026 
1027 	/*
1028 	 * Create two Elf_Data for .symtab section of output object, one
1029 	 * for local symbols and another for global symbols. Note that
1030 	 * local symbols appear first in the .symtab.
1031 	 */
1032 	sy_buf = sy->buf;
1033 	if (sy_buf->nls > 0) {
1034 		if ((lsydata = elf_newdata(sy->os)) == NULL)
1035 			errx(EXIT_FAILURE, "elf_newdata() failed: %s.",
1036 			     elf_errmsg(-1));
1037 		if (ecp->oec == ELFCLASS32) {
1038 			lsydata->d_align	= 4;
1039 			lsydata->d_off		= 0;
1040 			lsydata->d_buf		= sy_buf->l32;
1041 			lsydata->d_size		= sy_buf->nls *
1042 				sizeof(Elf32_Sym);
1043 			lsydata->d_type		= ELF_T_SYM;
1044 			lsydata->d_version	= EV_CURRENT;
1045 		} else {
1046 			lsydata->d_align	= 8;
1047 			lsydata->d_off		= 0;
1048 			lsydata->d_buf		= sy_buf->l64;
1049 			lsydata->d_size		= sy_buf->nls *
1050 				sizeof(Elf64_Sym);
1051 			lsydata->d_type		= ELF_T_SYM;
1052 			lsydata->d_version	= EV_CURRENT;
1053 		}
1054 	}
1055 	if (sy_buf->ngs > 0) {
1056 		if ((gsydata = elf_newdata(sy->os)) == NULL)
1057 			errx(EXIT_FAILURE, "elf_newdata() failed: %s.",
1058 			     elf_errmsg(-1));
1059 		if (ecp->oec == ELFCLASS32) {
1060 			gsydata->d_align	= 4;
1061 			gsydata->d_off		= sy_buf->nls *
1062 				sizeof(Elf32_Sym);
1063 			gsydata->d_buf		= sy_buf->g32;
1064 			gsydata->d_size		= sy_buf->ngs *
1065 				sizeof(Elf32_Sym);
1066 			gsydata->d_type		= ELF_T_SYM;
1067 			gsydata->d_version	= EV_CURRENT;
1068 		} else {
1069 			gsydata->d_align	= 8;
1070 			gsydata->d_off		= sy_buf->nls *
1071 				sizeof(Elf64_Sym);
1072 			gsydata->d_buf		= sy_buf->g64;
1073 			gsydata->d_size		= sy_buf->ngs *
1074 				sizeof(Elf64_Sym);
1075 			gsydata->d_type		= ELF_T_SYM;
1076 			gsydata->d_version	= EV_CURRENT;
1077 		}
1078 	}
1079 
1080 	/*
1081 	 * Create two Elf_Data for .strtab, one for local symbol name
1082 	 * and another for globals. Same as .symtab, local symbol names
1083 	 * appear first.
1084 	 */
1085 	st_buf = st->buf;
1086 	if ((lstdata = elf_newdata(st->os)) == NULL)
1087 		errx(EXIT_FAILURE, "elf_newdata() failed: %s.",
1088 		    elf_errmsg(-1));
1089 	lstdata->d_align	= 1;
1090 	lstdata->d_off		= 0;
1091 	lstdata->d_buf		= st_buf->l.buf;
1092 	lstdata->d_size		= st_buf->l.sz;
1093 	lstdata->d_type		= ELF_T_BYTE;
1094 	lstdata->d_version	= EV_CURRENT;
1095 
1096 	if (st_buf->g.sz > 0) {
1097 		if ((gstdata = elf_newdata(st->os)) == NULL)
1098 			errx(EXIT_FAILURE, "elf_newdata() failed: %s.",
1099 			    elf_errmsg(-1));
1100 		gstdata->d_align	= 1;
1101 		gstdata->d_off		= lstdata->d_size;
1102 		gstdata->d_buf		= st_buf->g.buf;
1103 		gstdata->d_size		= st_buf->g.sz;
1104 		gstdata->d_type		= ELF_T_BYTE;
1105 		gstdata->d_version	= EV_CURRENT;
1106 	}
1107 
1108 	shy.sh_addr		= 0;
1109 	shy.sh_addralign	= (ecp->oec == ELFCLASS32 ? 4 : 8);
1110 	shy.sh_size		= sy->sz;
1111 	shy.sh_type		= SHT_SYMTAB;
1112 	shy.sh_flags		= 0;
1113 	shy.sh_entsize		= gelf_fsize(ecp->eout, ELF_T_SYM, 1,
1114 	    EV_CURRENT);
1115 	/*
1116 	 * According to SYSV abi, here sh_info is one greater than
1117 	 * the symbol table index of the last local symbol(binding
1118 	 * STB_LOCAL).
1119 	 */
1120 	shy.sh_info		= sy_buf->nls;
1121 
1122 	sht.sh_addr		= 0;
1123 	sht.sh_addralign	= 1;
1124 	sht.sh_size		= st->sz;
1125 	sht.sh_type		= SHT_STRTAB;
1126 	sht.sh_flags		= 0;
1127 	sht.sh_entsize		= 0;
1128 	sht.sh_info		= 0;
1129 	sht.sh_link		= 0;
1130 
1131 	if (!gelf_update_shdr(sy->os, &shy))
1132 		errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1133 		    elf_errmsg(-1));
1134 	if (!gelf_update_shdr(st->os, &sht))
1135 		errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s",
1136 		    elf_errmsg(-1));
1137 }
1138 
1139 void
1140 add_to_symop_list(struct elfcopy *ecp, const char *name, const char *newname,
1141     unsigned int op)
1142 {
1143 	struct symop *s;
1144 
1145 	assert (name != NULL);
1146 	STAILQ_FOREACH(s, &ecp->v_symop, symop_list)
1147 		if (!strcmp(name, s->name))
1148 			goto found;
1149 
1150 	if ((s = calloc(1, sizeof(*s))) == NULL)
1151 		errx(EXIT_FAILURE, "not enough memory");
1152 	STAILQ_INSERT_TAIL(&ecp->v_symop, s, symop_list);
1153 	s->name = name;
1154 found:
1155 	if (op == SYMOP_REDEF)
1156 		s->newname = newname;
1157 	s->op |= op;
1158 }
1159 
1160 struct symop *
1161 lookup_symop_list(struct elfcopy *ecp, const char *name, unsigned int op)
1162 {
1163 	struct symop *s, *ret;
1164 	const char *pattern;
1165 
1166 	STAILQ_FOREACH(s, &ecp->v_symop, symop_list) {
1167 		if ((s->op & op) == 0)
1168 			continue;
1169 		if (name == NULL || !strcmp(name, s->name))
1170 			return (s);
1171 		if ((ecp->flags & WILDCARD) == 0)
1172 			continue;
1173 
1174 		/* Handle wildcards. */
1175 		pattern = s->name;
1176 		if (pattern[0] == '!') {
1177 			/* Negative match. */
1178 			pattern++;
1179 			ret = NULL;
1180 		} else {
1181 			/* Regular wildcard match. */
1182 			ret = s;
1183 		}
1184 		if (!fnmatch(pattern, name, 0))
1185 			return (ret);
1186 	}
1187 
1188 	return (NULL);
1189 }
1190 
1191 static int
1192 lookup_exact_string(hash_head *buckets, const char *buf, const char *s)
1193 {
1194 	struct sthash	*sh;
1195 	uint32_t	 hash;
1196 
1197 	hash = str_hash(s);
1198 	LIST_FOREACH(sh, &buckets[hash], sh_next)
1199 		if (strcmp(buf + sh->sh_off, s) == 0)
1200 			return sh->sh_off;
1201 	return (-1);
1202 }
1203 
1204 uint32_t
1205 str_hash(const char *s)
1206 {
1207 	uint32_t hash;
1208 
1209 	for (hash = 2166136261UL; *s; s++)
1210 		hash = (hash ^ *s) * 16777619;
1211 
1212 	return (hash & (STHASHSIZE - 1));
1213 }
1214