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