1 /*
2  * CDDL HEADER START
3  *
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.
7  *
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.
12  *
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]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include	<stdio.h>
27 #include	<strings.h>
28 #include	<sys/elf.h>
29 #include	<sys/elf_SPARC.h>
30 #include	<alloca.h>
31 #include	"_rtld.h"
32 #include	"_elf.h"
33 #include	"msg.h"
34 #include	"conv.h"
35 
36 /*
37  *
38  *  Matrix of legal combinations of usage of a given register:
39  *
40  *	Obj1\Obj2       Scratch Named
41  *	Scratch          OK      NO
42  *	Named            NO      *
43  *
44  *  * OK if the symbols are identical, NO if they are not.  Two symbols
45  *  are identical if and only if one of the following is true:
46  *        A. They are both global and have the same name.
47  *        B. They are both local, have the same name, and are defined in
48  *        the same object.  (Note that a local symbol in one object is
49  *        never identical to a local symbol in another object, even if the
50  *        name is the same.)
51  *
52  *  Matrix of legal combinations of st_shndx for the same register symbol:
53  *
54  *	Obj1\Obj2       UNDEF   ABS
55  *	UNDEF            OK      OK
56  *	ABS              OK      NO
57  */
58 
59 /*
60  * Test the compatiblity of two register symbols, 0 pass, >0 fail
61  */
62 static uintptr_t
check_regsyms(Sym * sym1,const char * name1,Sym * sym2,const char * name2)63 check_regsyms(Sym *sym1, const char *name1, Sym *sym2, const char *name2)
64 {
65 	if ((sym1->st_name == 0) && (sym2->st_name == 0))
66 		return (0);	/* scratches are always compatible */
67 
68 	if ((ELF_ST_BIND(sym1->st_info) == STB_LOCAL) ||
69 	    (ELF_ST_BIND(sym2->st_info) == STB_LOCAL)) {
70 		if (sym1->st_value == sym2->st_value)
71 			return (1);	/* local symbol incompat */
72 		return (0);		/* no other prob from locals */
73 	}
74 
75 	if (sym1->st_value == sym2->st_value) {
76 		/* NOTE this just avoids strcmp */
77 		if ((sym1->st_name == 0) || (sym2->st_name == 0))
78 			return (2);	/* can't match scratch to named */
79 
80 		if (strcmp(name1, name2) != 0)
81 			return (4);	/* diff name, same register value */
82 
83 		if ((sym1->st_shndx == SHN_ABS) && (sym2->st_shndx == SHN_ABS))
84 			return (3);	/* multiply defined */
85 	} else if (strcmp(name1, name2) == 0)
86 		return (5);	/* same name, diff register value */
87 
88 	return (0);
89 }
90 
91 int
elf_regsyms(Rt_map * lmp)92 elf_regsyms(Rt_map *lmp)
93 {
94 	Dyn	*dyn;
95 	Dyninfo	*dip;
96 	Sym	*symdef;
97 	ulong_t	rsymndx;
98 
99 	/*
100 	 * Scan through the .dynamic section of this object looking for all
101 	 * DT_REGISTER entries.  For each DT_REGISTER entry found identify the
102 	 * register symbol it identifies and confirm that it doesn't conflict
103 	 * with any other register symbols.
104 	 */
105 	for (dyn = DYN(lmp), dip = DYNINFO(lmp);
106 	    !(dip->di_flags & FLG_DI_IGNORE); dyn++, dip++) {
107 		Reglist	*rp;
108 
109 		if ((dip->di_flags & FLG_DI_REGISTER) == 0)
110 			continue;
111 
112 		/*
113 		 * Get the local symbol table entry.
114 		 */
115 		rsymndx = dyn->d_un.d_val;
116 		symdef = (Sym *)((unsigned long)SYMTAB(lmp) +
117 		    (rsymndx * SYMENT(lmp)));
118 
119 		for (rp = reglist; rp; rp = rp->rl_next) {
120 			Conv_inv_buf_t	inv_buf;
121 			const char	*str, *sym1, *sym2;
122 
123 			if (rp->rl_sym == symdef) {
124 				/*
125 				 * Same symbol definition - everything is a-ok.
126 				 */
127 				return (1);
128 			}
129 
130 			sym1 = (STRTAB(rp->rl_lmp) + rp->rl_sym->st_name);
131 			sym2 = (STRTAB(lmp) + symdef->st_name);
132 
133 			if (check_regsyms(rp->rl_sym, sym1, symdef, sym2) == 0)
134 				continue;
135 
136 			if ((str = demangle(sym1)) != sym1) {
137 				char	*_str = alloca(strlen(str) + 1);
138 				(void) strcpy(_str, str);
139 				sym1 = (const char *)_str;
140 			}
141 			sym2 = demangle(sym2);
142 
143 			if (LIST(lmp)->lm_flags & LML_FLG_TRC_WARN) {
144 				(void) printf(MSG_INTL(MSG_LDD_REG_SYMCONF),
145 				    conv_sym_SPARC_value(symdef->st_value,
146 				    0, &inv_buf), NAME(rp->rl_lmp),
147 				    sym1, NAME(lmp), sym2);
148 			} else {
149 				eprintf(LIST(lmp), ERR_FATAL,
150 				    MSG_INTL(MSG_REG_SYMCONF),
151 				    conv_sym_SPARC_value(symdef->st_value,
152 				    0, &inv_buf), NAME(rp->rl_lmp),
153 				    sym1, NAME(lmp), sym2);
154 				return (0);
155 			}
156 		}
157 		if ((rp = calloc(sizeof (Reglist), 1)) == NULL)
158 			return (0);
159 		rp->rl_lmp = lmp;
160 		rp->rl_sym = symdef;
161 		rp->rl_next = reglist;
162 		reglist = rp;
163 	}
164 	return (1);
165 }
166