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 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 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 * 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 * 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 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