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 #define	ELF_TARGET_SPARC
26 
27 #include	<stdio.h>
28 #include	<string.h>
29 #include	<alloca.h>
30 #include	<sys/types.h>
31 #include	<debug.h>
32 #include	"msg.h"
33 #include	"_libld.h"
34 #include	"machsym.sparc.h"
35 
36 /*
37  * Matrix of legal combinations of usage of a given register:
38  *
39  *	Obj1 \ Obj2      Scratch	Named
40  *	Scratch          OK		NO
41  *	Named            NO		*
42  *
43  * (*) OK if the symbols are identical, NO if they are not.  Two symbols
44  * are identical if and only if one of the following is true:
45  *   A. They are both global and have the same name.
46  *   B. They are both local, have the same name, and are defined in the same
47  *	object.  (Note that a local symbol in one object is never identical to
48  *	a local symbol in another object, even if the name is the same.)
49  *
50  * Matrix of legal combinations of st_shndx for the same register symbol:
51  *
52  *	Obj1 \ Obj2      UNDEF		ABS
53  *	UNDEF            OK		OK
54  *	ABS              OK		NO
55  *
56  */
57 int
ld_reg_check_sparc(Sym_desc * sdp,Sym * nsym,const char * nname,Ifl_desc * ifl,Ofl_desc * ofl)58 ld_reg_check_sparc(Sym_desc *sdp, Sym *nsym, const char *nname, Ifl_desc *ifl,
59     Ofl_desc *ofl)
60 {
61 	Sym		*osym = sdp->sd_sym;
62 	const char	*oname = sdp->sd_name;
63 	Conv_inv_buf_t	inv_buf1, inv_buf2;
64 
65 	/*
66 	 * Scratch register definitions are compatible.
67 	 */
68 	if ((osym->st_name == 0) && (nsym->st_name == 0))
69 		return (0);
70 
71 	/*
72 	 * A local and a global, or another local is incompatible.
73 	 */
74 	if ((ELF_ST_BIND(osym->st_info) == STB_LOCAL) ||
75 	    (ELF_ST_BIND(nsym->st_info) == STB_LOCAL)) {
76 		if (osym->st_value == nsym->st_value) {
77 
78 			ld_eprintf(ofl, ERR_FATAL,
79 			    MSG_INTL(MSG_SYM_INCOMPREG3),
80 			    conv_sym_SPARC_value(osym->st_value, 0, &inv_buf1),
81 			    sdp->sd_file->ifl_name, demangle(oname),
82 			    ifl->ifl_name, demangle(nname));
83 			return (1);
84 		}
85 		return (0);
86 	}
87 
88 	if (osym->st_value == nsym->st_value) {
89 		/*
90 		 * A scratch register and a named register are incompatible.
91 		 * So are two different named registers.
92 		 */
93 		if (((osym->st_name == 0) || (nsym->st_name == 0)) ||
94 		    (strcmp(oname, nname) != 0)) {
95 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_INCOMPREG1),
96 			    conv_sym_SPARC_value(osym->st_value, 0, &inv_buf1),
97 			    sdp->sd_file->ifl_name, demangle(oname),
98 			    ifl->ifl_name, demangle(nname));
99 			return (1);
100 		}
101 
102 		/*
103 		 * A multiply initialized symbol is also illegal.
104 		 */
105 		if ((osym->st_shndx == SHN_ABS) &&
106 		    (nsym->st_shndx == SHN_ABS)) {
107 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_MULTINIREG),
108 			    conv_sym_SPARC_value(osym->st_value, 0, &inv_buf1),
109 			    demangle(nname), sdp->sd_file->ifl_name,
110 			    ifl->ifl_name);
111 			return (1);
112 		}
113 
114 	} else if (strcmp(oname, nname) == 0) {
115 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_INCOMPREG2),
116 		    demangle(sdp->sd_name), sdp->sd_file->ifl_name,
117 		    conv_sym_SPARC_value(osym->st_value, 0, &inv_buf1),
118 		    ifl->ifl_name,
119 		    conv_sym_SPARC_value(nsym->st_value, 0, &inv_buf2));
120 		return (1);
121 	}
122 	return (0);
123 }
124 
125 int
ld_mach_sym_typecheck_sparc(Sym_desc * sdp,Sym * nsym,Ifl_desc * ifl,Ofl_desc * ofl)126 ld_mach_sym_typecheck_sparc(Sym_desc *sdp, Sym *nsym, Ifl_desc *ifl,
127     Ofl_desc *ofl)
128 {
129 	Conv_inv_buf_t	inv_buf1, inv_buf2;
130 	Sym		*osym = sdp->sd_sym;
131 	Byte		otype = ELF_ST_TYPE(osym->st_info);
132 	Byte		ntype = ELF_ST_TYPE(nsym->st_info);
133 
134 	if (otype != ntype) {
135 		if ((otype == STT_SPARC_REGISTER) ||
136 		    (ntype == STT_SPARC_REGISTER)) {
137 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_DIFFTYPE),
138 			    demangle(sdp->sd_name));
139 			ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_SYM_FILETYPES),
140 			    sdp->sd_file->ifl_name, conv_sym_info_type(
141 			    sdp->sd_file->ifl_ehdr->e_machine, otype,
142 			    0, &inv_buf1), ifl->ifl_name,
143 			    conv_sym_info_type(ifl->ifl_ehdr->e_machine,
144 			    ntype, 0, &inv_buf2));
145 			return (1);
146 		}
147 	} else if (otype == STT_SPARC_REGISTER)
148 		return (ld_reg_check_sparc(sdp, nsym, sdp->sd_name, ifl, ofl));
149 
150 	return (0);
151 }
152 
153 static const char *registers[] = { 0,
154 	MSG_ORIG(MSG_STO_REGISTERG1),	MSG_ORIG(MSG_STO_REGISTERG2),
155 	MSG_ORIG(MSG_STO_REGISTERG3),	MSG_ORIG(MSG_STO_REGISTERG4),
156 	MSG_ORIG(MSG_STO_REGISTERG5),	MSG_ORIG(MSG_STO_REGISTERG6),
157 	MSG_ORIG(MSG_STO_REGISTERG7)
158 };
159 
160 const char *
ld_is_regsym_sparc(Ofl_desc * ofl,Ifl_desc * ifl,Sym * sym,const char * strs,int symndx,Word shndx,const char * symsecname,sd_flag_t * flags)161 ld_is_regsym_sparc(Ofl_desc *ofl, Ifl_desc *ifl, Sym *sym, const char *strs,
162     int symndx, Word shndx, const char *symsecname, sd_flag_t *flags)
163 {
164 	const char	*name;
165 
166 	/*
167 	 * Only do something if this is a register symbol.
168 	 */
169 	if (ELF_ST_TYPE(sym->st_info) != STT_SPARC_REGISTER)
170 		return (0);
171 
172 	/*
173 	 * Check for bogus register number.
174 	 */
175 	if ((sym->st_value < STO_SPARC_REGISTER_G1) ||
176 	    (sym->st_value > STO_SPARC_REGISTER_G7)) {
177 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_BADREG),
178 		    ifl->ifl_name, symsecname, symndx, EC_XWORD(sym->st_value));
179 		return ((const char *)S_ERROR);
180 	}
181 
182 	/*
183 	 * A register symbol can only be undefined or defined (absolute).
184 	 */
185 	if ((shndx != SHN_ABS) && (shndx != SHN_UNDEF)) {
186 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_BADREG),
187 		    ifl->ifl_name, symsecname, symndx, EC_XWORD(sym->st_value));
188 		return ((const char *)S_ERROR);
189 	}
190 
191 	/*
192 	 * Determine whether this is a scratch (unnamed) definition.
193 	 */
194 	if (sym->st_name == 0) {
195 		/*
196 		 * Check for bogus scratch register definitions.
197 		 */
198 		if ((ELF_ST_BIND(sym->st_info) != STB_GLOBAL) ||
199 		    (shndx != SHN_UNDEF)) {
200 			Conv_inv_buf_t inv_buf;
201 
202 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_BADSCRATCH),
203 			    ifl->ifl_name, symsecname, symndx,
204 			    conv_sym_SPARC_value(sym->st_value, 0, &inv_buf));
205 			return ((const char *)S_ERROR);
206 		}
207 
208 		/*
209 		 * Fabricate a name for this register so that this definition
210 		 * can be processed through the symbol resolution engine.
211 		 */
212 		name = registers[sym->st_value];
213 	} else
214 		name = strs + sym->st_name;
215 
216 	/*
217 	 * Indicate we're dealing with a register and return its name.
218 	 */
219 	*flags |= FLG_SY_REGSYM;
220 	return (name);
221 }
222 
223 Sym_desc *
ld_reg_find_sparc(Sym * sym,Ofl_desc * ofl)224 ld_reg_find_sparc(Sym *sym, Ofl_desc *ofl)
225 {
226 	if (ofl->ofl_regsyms == NULL)
227 		return (NULL);
228 
229 	return (ofl->ofl_regsyms[sym->st_value]);
230 }
231 
232 int
ld_reg_enter_sparc(Sym_desc * sdp,Ofl_desc * ofl)233 ld_reg_enter_sparc(Sym_desc *sdp, Ofl_desc *ofl)
234 {
235 	if (ofl->ofl_regsyms == NULL) {
236 
237 		ofl->ofl_regsymsno = STO_SPARC_REGISTER_G7 + 1;
238 
239 		if ((ofl->ofl_regsyms = libld_calloc(sizeof (Sym_desc *),
240 		    ofl->ofl_regsymsno)) == NULL) {
241 			ofl->ofl_flags |= FLG_OF_FATAL;
242 			return (0);
243 		}
244 	}
245 
246 	ofl->ofl_regsyms[sdp->sd_sym->st_value] = sdp;
247 	return (1);
248 }
249