ld/ldfile.c

   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
  20 /*
  21  ldfile.c
  22
  23  look after all the file stuff
  24
  25  */
  26
  27 #include "bfd.h"
  28 #include "sysdep.h"
  29
  30 #include "ldmisc.h"
  31 #include "ldlang.h"
  32 #include "ldfile.h"
  33 #include <ctype.h>
  34 /* EXPORT */
  35 char *ldfile_input_filename;
  36 CONST char * ldfile_output_machine_name ="";
  37 unsigned long ldfile_output_machine;
  38 enum bfd_architecture ldfile_output_architecture;
  39
  40 /* IMPORT */
  41
  42 extern boolean had_script;
  43 extern boolean option_v;
  44
  45
  46 #ifdef VMS
  47 char *slash = "";
  48 #else
  49 char *slash = "/";
  50 #endif
  51
  52
  53
  54
  55 /* LOCAL */
  56 typedef struct search_dirs
  57 {
  58   char *name;
  59   struct search_dirs *next;
  60 } search_dirs_type;
  61
  62 static search_dirs_type *search_head;
  63 static search_dirs_type **search_tail_ptr = &search_head;
  64
  65 typedef struct search_arch
  66 {
  67   char *name;
  68   struct search_arch *next;
  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
  74
  75
  76 void
  77 ldfile_add_library_path(name)
  78 char *name;
  79 {
  80   search_dirs_type *new =
  81     (search_dirs_type *)ldmalloc((bfd_size_type)(sizeof(search_dirs_type)));
  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);
  95   if (option_v == true ) {
  96     info("attempt to open %s %s\n", attempt,
  97                 (entry->the_bfd == (bfd *)NULL) ? "failed" : "succeeded" );
  98   }
  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,
 119                 "%s%s%s%s%s%s",
 120                 search->name,
 121                 slash,
 122                 lib,
 123                 entry->filename, arch, suffix);
 124       }
 125       else {
 126         if (entry->filename[0] == '/' || entry->filename[0] == '.') {
 127           strcpy(buffer, entry->filename);
 128         } else {
 129           sprintf(buffer,"%s%s%s",search->name, slash, entry->filename);
 130         }
 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;
 161       /* Try to open <filename><suffix> or lib<filename><suffix>.a */
 162
 163       for (arch = search_arch_head;
 164            arch != (search_arch_type *)NULL;
 165            arch = arch->next) {
 166         if (open_a(arch->name,entry,"lib",".a") != (bfd *)NULL) {
 167           return;
 168         }
 169 #ifdef VMS
 170         if (open_a(arch->name,entry,":lib",".a") != (bfd *)NULL) {
 171           return;
 172         }
 173 #endif
 174
 175       }
 176
 177
 178     }
 179   else {
 180     entry->the_bfd = cached_bfd_openr (entry->filename, entry);
 181
 182   }
 183   if (!entry->the_bfd)  einfo("%F%P: Can't open %s, %E\n", entry->filename);
 184
 185 }
 186
 187
 188 /* Try to open NAME; if that fails, try NAME with EXTEN appended to it.  */
 189
 190 static FILE *
 191 try_open(name, exten)
 192 char *name;
 193 char *exten;
 194 {
 195   FILE *result;
 196   char buff[1000];
 197
 198   result = fopen(name, "r");
 199   if (option_v == true) {
 200     if (result == (FILE *)NULL) {
 201       info("can't find ");
 202     }
 203     info("%s\n",name);
 204   }
 205   if (result != (FILE *)NULL) {
 206     return result;
 207   }
 208
 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);
 217     }
 218   }
 219   return result;
 220 }
 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
 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];
 233
 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
 249 void
 250 ldfile_open_command_file(name)
 251 char *name;
 252 {
 253   FILE *ldlex_input_stack;
 254   ldlex_input_stack = find_a_name(name, "");
 255
 256   if (ldlex_input_stack == (FILE *)NULL) {
 257     einfo("%P%F cannot open load script file %s, %E\n",name);
 258   }
 259   lex_push_file(ldlex_input_stack, name);
 260
 261   ldfile_input_filename = name;
 262   had_script = true;
 263 }
 264
 265
 266
 267
 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 ){
 297     einfo("%P%F: unknown architecture: %s\n",name);
 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 =
 309     (search_arch_type *)ldmalloc((bfd_size_type)(sizeof(search_arch_type)));
 310
 311
 312   if (*name != '\0') {
 313     if (ldfile_output_machine_name[0] != '\0') {
 314       einfo("%P%F: target architecture respecified\n");
 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
 330 void
 331 ldfile_add_arch (in_name)
 332      CONST char * in_name;
 333 {
 334   char *name = buystring(in_name);
 335   search_arch_type *new =
 336     (search_arch_type *)ldmalloc((bfd_size_type)(sizeof(search_arch_type)));
 337
 338   ldfile_output_machine_name = in_name;
 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 }
 350 #endif
 351
 352 /* Set the output architecture */
 353 void
 354 ldfile_set_output_arch (string)
 355      CONST char *string;
 356 {
 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;
 363   }
 364   else {
 365     einfo("%P%F: Can't represent machine `%s'\n", string);
 366   }
 367 }