8c7d828d82e2f9da8e03f6750a0ffcbb5cf3c251
1 // resolve.cc -- symbol resolution for gold
13 // Resolve a symbol. This is called the second and subsequent times
14 // we see a symbol. TO is the pre-existing symbol. SYM is the new
15 // symbol, seen in OBJECT.
17 template<int size
, bool big_endian
>
19 Symbol_table::resolve(Symbol
* to
,
20 const elfcpp::Sym
<size
, big_endian
>& sym
,
23 if (object
->target()->has_resolve())
25 object
->sized_target
<size
, big_endian
>()->resolve(to
, sym
, object
);
29 // Build a little code for each symbol.
30 // Bit 0: 0 for global, 1 for weak.
31 // Bit 1: 0 for regular object, 1 for shared object
32 // Bits 2-3: 0 for normal, 1 for undefined, 2 for common
33 // This gives us values from 0 to 11:
52 switch (to
->binding())
54 case elfcpp::STB_GLOBAL
:
58 case elfcpp::STB_WEAK
:
62 case elfcpp::STB_LOCAL
:
63 // We should only see externally visible symbols in the symbol
68 // Any target which wants to handle STB_LOOS, etc., needs to
69 // define a resolve method.
73 if (to
->object() != NULL
&& to
->object()->is_dynamic())
78 case elfcpp::SHN_UNDEF
:
82 case elfcpp::SHN_COMMON
:
91 switch (sym
.get_st_bind())
93 case elfcpp::STB_GLOBAL
:
97 case elfcpp::STB_WEAK
:
101 case elfcpp::STB_LOCAL
:
103 _("%s: %s: invalid STB_LOCAL symbol %s in external symbols\n"),
104 program_name
, object
->name().c_str(), to
->name());
109 _("%s: %s: unsupported symbol binding %d for symbol %s\n"),
110 program_name
, object
->name().c_str(),
111 static_cast<int>(sym
.get_st_bind()), to
->name());
115 if (object
->is_dynamic())
116 frombits
|= (1 << 1);
118 switch (sym
.get_st_shndx())
120 case elfcpp::SHN_UNDEF
:
121 frombits
|= (1 << 2);
124 case elfcpp::SHN_COMMON
:
125 frombits
|= (2 << 2);
132 // We use a giant switch table for symbol resolution. This code is
133 // unwieldy, but: 1) it is efficient; 2) we definitely handle all
134 // cases; 3) it is easy to change the handling of a particular case.
135 // The alternative would be a series of conditionals, but it is easy
136 // to get the ordering wrong. This could also be done as a table,
137 // but that is no easier to understand than this large switch
140 switch (tobits
* 16 + frombits
)
143 // Two definitions of the same symbol.
144 fprintf(stderr
, "%s: %s: multiple definition of %s\n",
145 program_name
, object
->name().c_str(), to
->name());
146 // FIXME: Report locations. Record that we have seen an error.
149 case WEAK_DEF
* 16 + DEF
:
150 // In the original SVR4 linker, a weak definition followed by a
151 // regular definition was treated as a multiple definition
152 // error. In the Solaris linker and the GNU linker, a weak
153 // definition followed by a regular definition causes the
154 // regular definition to be ignored. We are currently
155 // compatible with the GNU linker. In the future we should add
156 // a target specific option to change this. FIXME.
159 case DYN_DEF
* 16 + DEF
:
160 case DYN_WEAK_DEF
* 16 + DEF
:
161 case UNDEF
* 16 + DEF
:
162 case WEAK_UNDEF
* 16 + DEF
:
163 case DYN_UNDEF
* 16 + DEF
:
164 case DYN_WEAK_UNDEF
* 16 + DEF
:
165 case COMMON
* 16 + DEF
:
166 case WEAK_COMMON
* 16 + DEF
:
167 case DYN_COMMON
* 16 + DEF
:
168 case DYN_WEAK_COMMON
* 16 + DEF
:
170 case DEF
* 16 + WEAK_DEF
:
171 case WEAK_DEF
* 16 + WEAK_DEF
:
172 case DYN_DEF
* 16 + WEAK_DEF
:
173 case DYN_WEAK_DEF
* 16 + WEAK_DEF
:
174 case UNDEF
* 16 + WEAK_DEF
:
175 case WEAK_UNDEF
* 16 + WEAK_DEF
:
176 case DYN_UNDEF
* 16 + WEAK_DEF
:
177 case DYN_WEAK_UNDEF
* 16 + WEAK_DEF
:
178 case COMMON
* 16 + WEAK_DEF
:
179 case WEAK_COMMON
* 16 + WEAK_DEF
:
180 case DYN_COMMON
* 16 + WEAK_DEF
:
181 case DYN_WEAK_COMMON
* 16 + WEAK_DEF
:
183 case DEF
* 16 + DYN_DEF
:
184 case WEAK_DEF
* 16 + DYN_DEF
:
185 case DYN_DEF
* 16 + DYN_DEF
:
186 case DYN_WEAK_DEF
* 16 + DYN_DEF
:
187 case UNDEF
* 16 + DYN_DEF
:
188 case WEAK_UNDEF
* 16 + DYN_DEF
:
189 case DYN_UNDEF
* 16 + DYN_DEF
:
190 case DYN_WEAK_UNDEF
* 16 + DYN_DEF
:
191 case COMMON
* 16 + DYN_DEF
:
192 case WEAK_COMMON
* 16 + DYN_DEF
:
193 case DYN_COMMON
* 16 + DYN_DEF
:
194 case DYN_WEAK_COMMON
* 16 + DYN_DEF
:
196 case DEF
* 16 + DYN_WEAK_DEF
:
197 case WEAK_DEF
* 16 + DYN_WEAK_DEF
:
198 case DYN_DEF
* 16 + DYN_WEAK_DEF
:
199 case DYN_WEAK_DEF
* 16 + DYN_WEAK_DEF
:
200 case UNDEF
* 16 + DYN_WEAK_DEF
:
201 case WEAK_UNDEF
* 16 + DYN_WEAK_DEF
:
202 case DYN_UNDEF
* 16 + DYN_WEAK_DEF
:
203 case DYN_WEAK_UNDEF
* 16 + DYN_WEAK_DEF
:
204 case COMMON
* 16 + DYN_WEAK_DEF
:
205 case WEAK_COMMON
* 16 + DYN_WEAK_DEF
:
206 case DYN_COMMON
* 16 + DYN_WEAK_DEF
:
207 case DYN_WEAK_COMMON
* 16 + DYN_WEAK_DEF
:
209 case DEF
* 16 + UNDEF
:
210 case WEAK_DEF
* 16 + UNDEF
:
211 case DYN_DEF
* 16 + UNDEF
:
212 case DYN_WEAK_DEF
* 16 + UNDEF
:
213 case UNDEF
* 16 + UNDEF
:
214 case WEAK_UNDEF
* 16 + UNDEF
:
215 case DYN_UNDEF
* 16 + UNDEF
:
216 case DYN_WEAK_UNDEF
* 16 + UNDEF
:
217 case COMMON
* 16 + UNDEF
:
218 case WEAK_COMMON
* 16 + UNDEF
:
219 case DYN_COMMON
* 16 + UNDEF
:
220 case DYN_WEAK_COMMON
* 16 + UNDEF
:
222 case DEF
* 16 + WEAK_UNDEF
:
223 case WEAK_DEF
* 16 + WEAK_UNDEF
:
224 case DYN_DEF
* 16 + WEAK_UNDEF
:
225 case DYN_WEAK_DEF
* 16 + WEAK_UNDEF
:
226 case UNDEF
* 16 + WEAK_UNDEF
:
227 case WEAK_UNDEF
* 16 + WEAK_UNDEF
:
228 case DYN_UNDEF
* 16 + WEAK_UNDEF
:
229 case DYN_WEAK_UNDEF
* 16 + WEAK_UNDEF
:
230 case COMMON
* 16 + WEAK_UNDEF
:
231 case WEAK_COMMON
* 16 + WEAK_UNDEF
:
232 case DYN_COMMON
* 16 + WEAK_UNDEF
:
233 case DYN_WEAK_COMMON
* 16 + WEAK_UNDEF
:
235 case DEF
* 16 + DYN_UNDEF
:
236 case WEAK_DEF
* 16 + DYN_UNDEF
:
237 case DYN_DEF
* 16 + DYN_UNDEF
:
238 case DYN_WEAK_DEF
* 16 + DYN_UNDEF
:
239 case UNDEF
* 16 + DYN_UNDEF
:
240 case WEAK_UNDEF
* 16 + DYN_UNDEF
:
241 case DYN_UNDEF
* 16 + DYN_UNDEF
:
242 case DYN_WEAK_UNDEF
* 16 + DYN_UNDEF
:
243 case COMMON
* 16 + DYN_UNDEF
:
244 case WEAK_COMMON
* 16 + DYN_UNDEF
:
245 case DYN_COMMON
* 16 + DYN_UNDEF
:
246 case DYN_WEAK_COMMON
* 16 + DYN_UNDEF
:
248 case DEF
* 16 + DYN_WEAK_UNDEF
:
249 case WEAK_DEF
* 16 + DYN_WEAK_UNDEF
:
250 case DYN_DEF
* 16 + DYN_WEAK_UNDEF
:
251 case DYN_WEAK_DEF
* 16 + DYN_WEAK_UNDEF
:
252 case UNDEF
* 16 + DYN_WEAK_UNDEF
:
253 case WEAK_UNDEF
* 16 + DYN_WEAK_UNDEF
:
254 case DYN_UNDEF
* 16 + DYN_WEAK_UNDEF
:
255 case DYN_WEAK_UNDEF
* 16 + DYN_WEAK_UNDEF
:
256 case COMMON
* 16 + DYN_WEAK_UNDEF
:
257 case WEAK_COMMON
* 16 + DYN_WEAK_UNDEF
:
258 case DYN_COMMON
* 16 + DYN_WEAK_UNDEF
:
259 case DYN_WEAK_COMMON
* 16 + DYN_WEAK_UNDEF
:
261 case DEF
* 16 + COMMON
:
262 case WEAK_DEF
* 16 + COMMON
:
263 case DYN_DEF
* 16 + COMMON
:
264 case DYN_WEAK_DEF
* 16 + COMMON
:
265 case UNDEF
* 16 + COMMON
:
266 case WEAK_UNDEF
* 16 + COMMON
:
267 case DYN_UNDEF
* 16 + COMMON
:
268 case DYN_WEAK_UNDEF
* 16 + COMMON
:
269 case COMMON
* 16 + COMMON
:
270 case WEAK_COMMON
* 16 + COMMON
:
271 case DYN_COMMON
* 16 + COMMON
:
272 case DYN_WEAK_COMMON
* 16 + COMMON
:
274 case DEF
* 16 + WEAK_COMMON
:
275 case WEAK_DEF
* 16 + WEAK_COMMON
:
276 case DYN_DEF
* 16 + WEAK_COMMON
:
277 case DYN_WEAK_DEF
* 16 + WEAK_COMMON
:
278 case UNDEF
* 16 + WEAK_COMMON
:
279 case WEAK_UNDEF
* 16 + WEAK_COMMON
:
280 case DYN_UNDEF
* 16 + WEAK_COMMON
:
281 case DYN_WEAK_UNDEF
* 16 + WEAK_COMMON
:
282 case COMMON
* 16 + WEAK_COMMON
:
283 case WEAK_COMMON
* 16 + WEAK_COMMON
:
284 case DYN_COMMON
* 16 + WEAK_COMMON
:
285 case DYN_WEAK_COMMON
* 16 + WEAK_COMMON
:
287 case DEF
* 16 + DYN_COMMON
:
288 case WEAK_DEF
* 16 + DYN_COMMON
:
289 case DYN_DEF
* 16 + DYN_COMMON
:
290 case DYN_WEAK_DEF
* 16 + DYN_COMMON
:
291 case UNDEF
* 16 + DYN_COMMON
:
292 case WEAK_UNDEF
* 16 + DYN_COMMON
:
293 case DYN_UNDEF
* 16 + DYN_COMMON
:
294 case DYN_WEAK_UNDEF
* 16 + DYN_COMMON
:
295 case COMMON
* 16 + DYN_COMMON
:
296 case WEAK_COMMON
* 16 + DYN_COMMON
:
297 case DYN_COMMON
* 16 + DYN_COMMON
:
298 case DYN_WEAK_COMMON
* 16 + DYN_COMMON
:
300 case DEF
* 16 + DYN_WEAK_COMMON
:
301 case WEAK_DEF
* 16 + DYN_WEAK_COMMON
:
302 case DYN_DEF
* 16 + DYN_WEAK_COMMON
:
303 case DYN_WEAK_DEF
* 16 + DYN_WEAK_COMMON
:
304 case UNDEF
* 16 + DYN_WEAK_COMMON
:
305 case WEAK_UNDEF
* 16 + DYN_WEAK_COMMON
:
306 case DYN_UNDEF
* 16 + DYN_WEAK_COMMON
:
307 case DYN_WEAK_UNDEF
* 16 + DYN_WEAK_COMMON
:
308 case COMMON
* 16 + DYN_WEAK_COMMON
:
309 case WEAK_COMMON
* 16 + DYN_WEAK_COMMON
:
310 case DYN_COMMON
* 16 + DYN_WEAK_COMMON
:
311 case DYN_WEAK_COMMON
* 16 + DYN_WEAK_COMMON
:
317 // Instantiate the templates we need. We could use the configure
318 // script to restrict this to only the ones needed for implemented
323 Symbol_table::resolve
<32, true>(
325 const elfcpp::Sym
<32, true>& sym
,
330 Symbol_table::resolve
<32, false>(
332 const elfcpp::Sym
<32, false>& sym
,
337 Symbol_table::resolve
<64, true>(
339 const elfcpp::Sym
<64, true>& sym
,
344 Symbol_table::resolve
<64, false>(
346 const elfcpp::Sym
<64, false>& sym
,
349 } // End namespace gold.
This page took 0.036714 seconds and 4 git commands to generate.