Commit | Line | Data |
---|---|---|
2fa0b342 DHW |
1 | |
2 | /* Copyright (C) 1991 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GLD, the Gnu Linker. | |
5 | ||
6 | GLD is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 1, or (at your option) | |
9 | any later version. | |
10 | ||
11 | GLD is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with GLD; see the file COPYING. If not, write to | |
18 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | ||
2fa0b342 DHW |
20 | /* |
21 | ldfile.c | |
22 | ||
23 | look after all the file stuff | |
24 | ||
25 | */ | |
26 | ||
2fa0b342 | 27 | #include "bfd.h" |
cffdcde9 | 28 | #include "sysdep.h" |
2fa0b342 DHW |
29 | |
30 | #include "ldmisc.h" | |
31 | #include "ldlang.h" | |
32 | #include "ldfile.h" | |
cffdcde9 | 33 | #include <ctype.h> |
2fa0b342 DHW |
34 | /* EXPORT */ |
35 | char *ldfile_input_filename; | |
070aa819 | 36 | CONST char * ldfile_output_machine_name =""; |
2fa0b342 DHW |
37 | unsigned long ldfile_output_machine; |
38 | enum bfd_architecture ldfile_output_architecture; | |
2fa0b342 DHW |
39 | |
40 | /* IMPORT */ | |
41 | ||
cffdcde9 | 42 | extern boolean had_script; |
2fa0b342 DHW |
43 | extern boolean option_v; |
44 | ||
45 | ||
cffdcde9 DM |
46 | #ifdef VMS |
47 | char *slash = ""; | |
48 | #else | |
49 | char *slash = "/"; | |
50 | #endif | |
51 | ||
2fa0b342 DHW |
52 | |
53 | ||
54 | ||
cffdcde9 DM |
55 | /* LOCAL */ |
56 | typedef struct search_dirs | |
2fa0b342 DHW |
57 | { |
58 | char *name; | |
cffdcde9 | 59 | struct search_dirs *next; |
2fa0b342 DHW |
60 | } search_dirs_type; |
61 | ||
62 | static search_dirs_type *search_head; | |
63 | static search_dirs_type **search_tail_ptr = &search_head; | |
64 | ||
cffdcde9 | 65 | typedef struct search_arch |
2fa0b342 DHW |
66 | { |
67 | char *name; | |
cffdcde9 | 68 | struct search_arch *next; |
2fa0b342 DHW |
69 | } search_arch_type; |
70 | ||
71 | static search_arch_type *search_arch_head; | |
72 | static search_arch_type **search_arch_tail_ptr = &search_arch_head; | |
73 | ||
1418c83b SC |
74 | |
75 | ||
2fa0b342 DHW |
76 | void |
77 | ldfile_add_library_path(name) | |
78 | char *name; | |
79 | { | |
80 | search_dirs_type *new = | |
cffdcde9 | 81 | (search_dirs_type *)ldmalloc((bfd_size_type)(sizeof(search_dirs_type))); |
2fa0b342 DHW |
82 | new->name = name; |
83 | new->next = (search_dirs_type*)NULL; | |
84 | *search_tail_ptr = new; | |
85 | search_tail_ptr = &new->next; | |
86 | } | |
87 | ||
88 | ||
89 | static bfd* | |
90 | cached_bfd_openr(attempt,entry) | |
91 | char *attempt; | |
92 | lang_input_statement_type *entry; | |
93 | { | |
94 | entry->the_bfd = bfd_openr(attempt, entry->target); | |
99fe4553 SC |
95 | if (option_v == true ) { |
96 | info("attempt to open %s %s\n", attempt, | |
97 | (entry->the_bfd == (bfd *)NULL) ? "failed" : "succeeded" ); | |
1418c83b | 98 | } |
2fa0b342 DHW |
99 | return entry->the_bfd; |
100 | } | |
101 | ||
102 | static bfd * | |
103 | open_a(arch, entry, lib, suffix) | |
104 | char *arch; | |
105 | lang_input_statement_type *entry; | |
106 | char *lib; | |
107 | char *suffix; | |
108 | { | |
109 | bfd*desc; | |
110 | search_dirs_type *search ; | |
111 | for (search = search_head; | |
112 | search != (search_dirs_type *)NULL; | |
113 | search = search->next) | |
114 | { | |
115 | char buffer[1000]; | |
116 | char *string; | |
117 | if (entry->is_archive == true) { | |
118 | sprintf(buffer, | |
cffdcde9 | 119 | "%s%s%s%s%s%s", |
2fa0b342 | 120 | search->name, |
cffdcde9 | 121 | slash, |
2fa0b342 DHW |
122 | lib, |
123 | entry->filename, arch, suffix); | |
124 | } | |
125 | else { | |
1418c83b SC |
126 | if (entry->filename[0] == '/' || entry->filename[0] == '.') { |
127 | strcpy(buffer, entry->filename); | |
128 | } else { | |
cffdcde9 | 129 | sprintf(buffer,"%s%s%s",search->name, slash, entry->filename); |
1418c83b | 130 | } |
2fa0b342 DHW |
131 | } |
132 | string = buystring(buffer); | |
133 | desc = cached_bfd_openr (string, entry); | |
134 | if (desc) | |
135 | { | |
136 | entry->filename = string; | |
137 | entry->search_dirs_flag = false; | |
138 | entry->the_bfd = desc; | |
139 | return desc; | |
140 | } | |
141 | free(string); | |
142 | } | |
143 | return (bfd *)NULL; | |
144 | } | |
145 | ||
146 | /* Open the input file specified by 'entry', and return a descriptor. | |
147 | The open file is remembered; if the same file is opened twice in a row, | |
148 | a new open is not actually done. */ | |
149 | ||
150 | void | |
151 | ldfile_open_file (entry) | |
152 | lang_input_statement_type *entry; | |
153 | { | |
154 | ||
155 | if (entry->superfile) | |
156 | ldfile_open_file (entry->superfile); | |
157 | ||
158 | if (entry->search_dirs_flag) | |
159 | { | |
160 | search_arch_type *arch; | |
1418c83b SC |
161 | /* Try to open <filename><suffix> or lib<filename><suffix>.a */ |
162 | ||
2fa0b342 DHW |
163 | for (arch = search_arch_head; |
164 | arch != (search_arch_type *)NULL; | |
165 | arch = arch->next) { | |
cffdcde9 | 166 | if (open_a(arch->name,entry,"lib",".a") != (bfd *)NULL) { |
2fa0b342 DHW |
167 | return; |
168 | } | |
cffdcde9 DM |
169 | #ifdef VMS |
170 | if (open_a(arch->name,entry,":lib",".a") != (bfd *)NULL) { | |
2fa0b342 DHW |
171 | return; |
172 | } | |
cffdcde9 | 173 | #endif |
2fa0b342 DHW |
174 | |
175 | } | |
176 | ||
177 | ||
178 | } | |
179 | else { | |
180 | entry->the_bfd = cached_bfd_openr (entry->filename, entry); | |
181 | ||
182 | } | |
cffdcde9 | 183 | if (!entry->the_bfd) einfo("%F%P: Can't open %s, %E\n", entry->filename); |
2fa0b342 DHW |
184 | |
185 | } | |
186 | ||
187 | ||
cffdcde9 | 188 | /* Try to open NAME; if that fails, try NAME with EXTEN appended to it. */ |
2fa0b342 DHW |
189 | |
190 | static FILE * | |
191 | try_open(name, exten) | |
192 | char *name; | |
193 | char *exten; | |
194 | { | |
195 | FILE *result; | |
196 | char buff[1000]; | |
cffdcde9 | 197 | |
2fa0b342 | 198 | result = fopen(name, "r"); |
1418c83b SC |
199 | if (option_v == true) { |
200 | if (result == (FILE *)NULL) { | |
201 | info("can't find "); | |
202 | } | |
2fa0b342 | 203 | info("%s\n",name); |
cffdcde9 DM |
204 | } |
205 | if (result != (FILE *)NULL) { | |
2fa0b342 DHW |
206 | return result; |
207 | } | |
2fa0b342 | 208 | |
cffdcde9 DM |
209 | if (*exten) { |
210 | sprintf(buff, "%s%s", name, exten); | |
211 | result = fopen(buff, "r"); | |
212 | if (option_v == true) { | |
213 | if (result == (FILE *)NULL) { | |
214 | info("can't find "); | |
215 | } | |
216 | info("%s\n", buff); | |
1418c83b | 217 | } |
2fa0b342 DHW |
218 | } |
219 | return result; | |
220 | } | |
cffdcde9 DM |
221 | |
222 | /* Try to open NAME; if that fails, look for it in any directories | |
223 | specified with -L, without and with EXTEND apppended. */ | |
224 | ||
2fa0b342 DHW |
225 | static FILE * |
226 | find_a_name(name, extend) | |
227 | char *name; | |
228 | char *extend; | |
229 | { | |
230 | search_dirs_type *search; | |
231 | FILE *result; | |
232 | char buffer[1000]; | |
cffdcde9 | 233 | |
2fa0b342 DHW |
234 | /* First try raw name */ |
235 | result = try_open(name,""); | |
236 | if (result == (FILE *)NULL) { | |
237 | /* Try now prefixes */ | |
238 | for (search = search_head; | |
239 | search != (search_dirs_type *)NULL; | |
240 | search = search->next) { | |
241 | sprintf(buffer,"%s/%s", search->name, name); | |
242 | result = try_open(buffer, extend); | |
243 | if (result)break; | |
244 | } | |
245 | } | |
246 | return result; | |
247 | } | |
248 | ||
cffdcde9 DM |
249 | void |
250 | ldfile_open_command_file(name) | |
2fa0b342 DHW |
251 | char *name; |
252 | { | |
cffdcde9 DM |
253 | FILE *ldlex_input_stack; |
254 | ldlex_input_stack = find_a_name(name, ""); | |
2fa0b342 DHW |
255 | |
256 | if (ldlex_input_stack == (FILE *)NULL) { | |
cffdcde9 | 257 | einfo("%P%F cannot open load script file %s, %E\n",name); |
2fa0b342 | 258 | } |
cffdcde9 DM |
259 | lex_push_file(ldlex_input_stack, name); |
260 | ||
2fa0b342 DHW |
261 | ldfile_input_filename = name; |
262 | had_script = true; | |
263 | } | |
264 | ||
265 | ||
266 | ||
267 | ||
99fe4553 SC |
268 | |
269 | #ifdef GNU960 | |
270 | static | |
271 | char * | |
272 | gnu960_map_archname( name ) | |
273 | char *name; | |
274 | { | |
275 | struct tabentry { char *cmd_switch; char *arch; }; | |
276 | static struct tabentry arch_tab[] = { | |
277 | "", "", | |
278 | "KA", "ka", | |
279 | "KB", "kb", | |
280 | "KC", "mc", /* Synonym for MC */ | |
281 | "MC", "mc", | |
282 | "CA", "ca", | |
283 | "SA", "ka", /* Functionally equivalent to KA */ | |
284 | "SB", "kb", /* Functionally equivalent to KB */ | |
285 | NULL, "" | |
286 | }; | |
287 | struct tabentry *tp; | |
288 | ||
289 | ||
290 | for ( tp = arch_tab; tp->cmd_switch != NULL; tp++ ){ | |
291 | if ( !strcmp(name,tp->cmd_switch) ){ | |
292 | break; | |
293 | } | |
294 | } | |
295 | ||
296 | if ( tp->cmd_switch == NULL ){ | |
cffdcde9 | 297 | einfo("%P%F: unknown architecture: %s\n",name); |
99fe4553 SC |
298 | } |
299 | return tp->arch; | |
300 | } | |
301 | ||
302 | ||
303 | ||
304 | void | |
305 | ldfile_add_arch(name) | |
306 | char *name; | |
307 | { | |
308 | search_arch_type *new = | |
cffdcde9 | 309 | (search_arch_type *)ldmalloc((bfd_size_type)(sizeof(search_arch_type))); |
99fe4553 SC |
310 | |
311 | ||
312 | if (*name != '\0') { | |
313 | if (ldfile_output_machine_name[0] != '\0') { | |
cffdcde9 | 314 | einfo("%P%F: target architecture respecified\n"); |
99fe4553 SC |
315 | return; |
316 | } | |
317 | ldfile_output_machine_name = name; | |
318 | } | |
319 | ||
320 | new->next = (search_arch_type*)NULL; | |
321 | new->name = gnu960_map_archname( name ); | |
322 | *search_arch_tail_ptr = new; | |
323 | search_arch_tail_ptr = &new->next; | |
324 | ||
325 | } | |
326 | ||
327 | #else /* not GNU960 */ | |
328 | ||
329 | ||
2fa0b342 | 330 | void |
cffdcde9 DM |
331 | ldfile_add_arch (in_name) |
332 | CONST char * in_name; | |
2fa0b342 | 333 | { |
1418c83b | 334 | char *name = buystring(in_name); |
2fa0b342 | 335 | search_arch_type *new = |
cffdcde9 | 336 | (search_arch_type *)ldmalloc((bfd_size_type)(sizeof(search_arch_type))); |
1418c83b SC |
337 | |
338 | ldfile_output_machine_name = in_name; | |
2fa0b342 DHW |
339 | |
340 | new->name = name; | |
341 | new->next = (search_arch_type*)NULL; | |
342 | while (*name) { | |
343 | if (isupper(*name)) *name = tolower(*name); | |
344 | name++; | |
345 | } | |
346 | *search_arch_tail_ptr = new; | |
347 | search_arch_tail_ptr = &new->next; | |
348 | ||
349 | } | |
99fe4553 | 350 | #endif |
a37cc0c0 SC |
351 | |
352 | /* Set the output architecture */ | |
353 | void | |
cffdcde9 DM |
354 | ldfile_set_output_arch (string) |
355 | CONST char *string; | |
a37cc0c0 | 356 | { |
cffdcde9 DM |
357 | bfd_arch_info_type *arch = bfd_scan_arch(string); |
358 | ||
359 | if (arch) { | |
360 | ldfile_output_architecture = arch->arch; | |
361 | ldfile_output_machine = arch->mach; | |
362 | ldfile_output_machine_name = arch->printable_name; | |
a37cc0c0 SC |
363 | } |
364 | else { | |
cffdcde9 | 365 | einfo("%P%F: Can't represent machine `%s'\n", string); |
a37cc0c0 SC |
366 | } |
367 | } |