353 lines
7.0 KiB
C
353 lines
7.0 KiB
C
|
|
/* Copyright (C) 1991 Free Software Foundation, Inc.
|
|
|
|
This file is part of GLD, the Gnu Linker.
|
|
|
|
GLD is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 1, or (at your option)
|
|
any later version.
|
|
|
|
GLD is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GLD; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
/*
|
|
$Id$
|
|
*/
|
|
|
|
/*
|
|
ldfile.c
|
|
|
|
look after all the file stuff
|
|
|
|
*/
|
|
|
|
#include "sysdep.h"
|
|
#include "bfd.h"
|
|
|
|
#include "ldmisc.h"
|
|
#include "ldlang.h"
|
|
#include "ldfile.h"
|
|
|
|
/* EXPORT */
|
|
char *ldfile_input_filename;
|
|
CONST char * ldfile_output_machine_name ="";
|
|
unsigned long ldfile_output_machine;
|
|
enum bfd_architecture ldfile_output_architecture;
|
|
boolean had_script;
|
|
|
|
/* IMPORT */
|
|
|
|
extern boolean option_v;
|
|
|
|
|
|
|
|
|
|
|
|
/* LOACL */
|
|
typedef struct search_dirs_struct
|
|
{
|
|
char *name;
|
|
struct search_dirs_struct *next;
|
|
} search_dirs_type;
|
|
|
|
static search_dirs_type *search_head;
|
|
static search_dirs_type **search_tail_ptr = &search_head;
|
|
|
|
typedef struct search_arch_struct
|
|
{
|
|
char *name;
|
|
struct search_arch_struct *next;
|
|
} search_arch_type;
|
|
|
|
static search_arch_type *search_arch_head;
|
|
static search_arch_type **search_arch_tail_ptr = &search_arch_head;
|
|
|
|
|
|
|
|
void
|
|
ldfile_add_library_path(name)
|
|
char *name;
|
|
{
|
|
search_dirs_type *new =
|
|
(search_dirs_type *)ldmalloc(sizeof(search_dirs_type));
|
|
new->name = name;
|
|
new->next = (search_dirs_type*)NULL;
|
|
*search_tail_ptr = new;
|
|
search_tail_ptr = &new->next;
|
|
}
|
|
|
|
|
|
static bfd*
|
|
cached_bfd_openr(attempt,entry)
|
|
char *attempt;
|
|
lang_input_statement_type *entry;
|
|
{
|
|
entry->the_bfd = bfd_openr(attempt, entry->target);
|
|
if (option_v == true ) {
|
|
info("attempt to open %s %s\n", attempt,
|
|
(entry->the_bfd == (bfd *)NULL) ? "failed" : "succeeded" );
|
|
}
|
|
return entry->the_bfd;
|
|
}
|
|
|
|
static bfd *
|
|
open_a(arch, entry, lib, suffix)
|
|
char *arch;
|
|
lang_input_statement_type *entry;
|
|
char *lib;
|
|
char *suffix;
|
|
{
|
|
bfd*desc;
|
|
search_dirs_type *search ;
|
|
for (search = search_head;
|
|
search != (search_dirs_type *)NULL;
|
|
search = search->next)
|
|
{
|
|
char buffer[1000];
|
|
char *string;
|
|
if (entry->is_archive == true) {
|
|
sprintf(buffer,
|
|
"%s/%s%s%s%s",
|
|
search->name,
|
|
lib,
|
|
entry->filename, arch, suffix);
|
|
}
|
|
else {
|
|
if (entry->filename[0] == '/' || entry->filename[0] == '.') {
|
|
strcpy(buffer, entry->filename);
|
|
} else {
|
|
sprintf(buffer,"%s/%s",search->name, entry->filename);
|
|
}
|
|
}
|
|
string = buystring(buffer);
|
|
desc = cached_bfd_openr (string, entry);
|
|
if (desc)
|
|
{
|
|
entry->filename = string;
|
|
entry->search_dirs_flag = false;
|
|
entry->the_bfd = desc;
|
|
return desc;
|
|
}
|
|
free(string);
|
|
}
|
|
return (bfd *)NULL;
|
|
}
|
|
|
|
/* Open the input file specified by 'entry', and return a descriptor.
|
|
The open file is remembered; if the same file is opened twice in a row,
|
|
a new open is not actually done. */
|
|
|
|
void
|
|
ldfile_open_file (entry)
|
|
lang_input_statement_type *entry;
|
|
{
|
|
|
|
if (entry->superfile)
|
|
ldfile_open_file (entry->superfile);
|
|
|
|
if (entry->search_dirs_flag)
|
|
{
|
|
search_arch_type *arch;
|
|
/* Try to open <filename><suffix> or lib<filename><suffix>.a */
|
|
|
|
for (arch = search_arch_head;
|
|
arch != (search_arch_type *)NULL;
|
|
arch = arch->next) {
|
|
if (open_a(arch->name,entry,"","") != (bfd *)NULL) {
|
|
return;
|
|
}
|
|
if (open_a(arch->name,entry,"lib",".a") != (bfd *)NULL) {
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
else {
|
|
entry->the_bfd = cached_bfd_openr (entry->filename, entry);
|
|
|
|
}
|
|
if (!entry->the_bfd) info("%F%P: %E %I\n", entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static FILE *
|
|
try_open(name, exten)
|
|
char *name;
|
|
char *exten;
|
|
{
|
|
FILE *result;
|
|
char buff[1000];
|
|
result = fopen(name, "r");
|
|
if (option_v == true) {
|
|
if (result == (FILE *)NULL) {
|
|
info("can't find ");
|
|
}
|
|
info("%s\n",name);
|
|
|
|
return result;
|
|
}
|
|
sprintf(buff, "%s%s", name, exten);
|
|
result = fopen(buff, "r");
|
|
|
|
if (option_v == true) {
|
|
if (result == (FILE *)NULL) {
|
|
info("can't find ");
|
|
}
|
|
info("%s\n", buff);
|
|
}
|
|
return result;
|
|
}
|
|
static FILE *
|
|
find_a_name(name, extend)
|
|
char *name;
|
|
char *extend;
|
|
{
|
|
search_dirs_type *search;
|
|
FILE *result;
|
|
char buffer[1000];
|
|
/* First try raw name */
|
|
result = try_open(name,"");
|
|
if (result == (FILE *)NULL) {
|
|
/* Try now prefixes */
|
|
for (search = search_head;
|
|
search != (search_dirs_type *)NULL;
|
|
search = search->next) {
|
|
sprintf(buffer,"%s/%s", search->name, name);
|
|
result = try_open(buffer, extend);
|
|
if (result)break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void ldfile_open_command_file(name)
|
|
char *name;
|
|
{
|
|
extern FILE *ldlex_input_stack;
|
|
ldlex_input_stack = find_a_name(name, ".ld");
|
|
|
|
if (ldlex_input_stack == (FILE *)NULL) {
|
|
info("%P%F cannot open load script file %s\n",name);
|
|
}
|
|
ldfile_input_filename = name;
|
|
had_script = true;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef GNU960
|
|
static
|
|
char *
|
|
gnu960_map_archname( name )
|
|
char *name;
|
|
{
|
|
struct tabentry { char *cmd_switch; char *arch; };
|
|
static struct tabentry arch_tab[] = {
|
|
"", "",
|
|
"KA", "ka",
|
|
"KB", "kb",
|
|
"KC", "mc", /* Synonym for MC */
|
|
"MC", "mc",
|
|
"CA", "ca",
|
|
"SA", "ka", /* Functionally equivalent to KA */
|
|
"SB", "kb", /* Functionally equivalent to KB */
|
|
NULL, ""
|
|
};
|
|
struct tabentry *tp;
|
|
|
|
|
|
for ( tp = arch_tab; tp->cmd_switch != NULL; tp++ ){
|
|
if ( !strcmp(name,tp->cmd_switch) ){
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( tp->cmd_switch == NULL ){
|
|
info("%P%F: unknown architecture: %s\n",name);
|
|
}
|
|
return tp->arch;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
ldfile_add_arch(name)
|
|
char *name;
|
|
{
|
|
search_arch_type *new =
|
|
(search_arch_type *)ldmalloc(sizeof(search_arch_type));
|
|
|
|
|
|
if (*name != '\0') {
|
|
if (ldfile_output_machine_name[0] != '\0') {
|
|
info("%P%F: target architecture respecified\n");
|
|
return;
|
|
}
|
|
ldfile_output_machine_name = name;
|
|
}
|
|
|
|
new->next = (search_arch_type*)NULL;
|
|
new->name = gnu960_map_archname( name );
|
|
*search_arch_tail_ptr = new;
|
|
search_arch_tail_ptr = &new->next;
|
|
|
|
}
|
|
|
|
#else /* not GNU960 */
|
|
|
|
|
|
void
|
|
DEFUN(ldfile_add_arch,(in_name),
|
|
CONST char * in_name)
|
|
{
|
|
char *name = buystring(in_name);
|
|
search_arch_type *new =
|
|
(search_arch_type *)ldmalloc(sizeof(search_arch_type));
|
|
|
|
ldfile_output_machine_name = in_name;
|
|
|
|
new->name = name;
|
|
new->next = (search_arch_type*)NULL;
|
|
while (*name) {
|
|
if (isupper(*name)) *name = tolower(*name);
|
|
name++;
|
|
}
|
|
*search_arch_tail_ptr = new;
|
|
search_arch_tail_ptr = &new->next;
|
|
|
|
}
|
|
#endif
|
|
|
|
/* Set the output architecture */
|
|
void
|
|
DEFUN(ldfile_set_output_arch,(string),
|
|
CONST char *string)
|
|
{
|
|
enum bfd_architecture arch;
|
|
unsigned long machine;
|
|
if (bfd_scan_arch_mach(string, &arch, &machine) == true) {
|
|
ldfile_output_architecture = arch;
|
|
ldfile_output_machine = machine;
|
|
ldfile_output_machine_name = string;
|
|
}
|
|
else {
|
|
info("%P%F: Can't represent machine `%s'\n", string);
|
|
}
|
|
}
|