-/* Copyright (C) 1991 Free Software Foundation, Inc.
+/* Linker command language support.
+ Copyright 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GLD, the Gnu Linker.
along with GLD; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-/* $Id$
- *
-*/
-
#include "bfd.h"
#include "sysdep.h"
#include "ldmisc.h"
#include "ldindr.h"
#include "ldctor.h"
+
/* FORWARDS */
-PROTO (static void, print_statements, (void));
-PROTO (static void, print_statement, (lang_statement_union_type *,
+static void print_statements PARAMS ((void));
+static void print_statement PARAMS ((lang_statement_union_type *,
lang_output_section_statement_type *));
+static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
+ size_t,
+ lang_statement_list_type*));
+
/* LOCALS */
static struct obstack stat_obstack;
static CONST char *current_target;
static CONST char *output_target;
static size_t longest_section_name = 8;
-static asection common_section;
static section_userdata_type common_section_userdata;
static lang_statement_list_type statement_list;
lang_output_section_statement_type *abs_output_section;
lang_statement_list_type *stat_ptr = &statement_list;
lang_input_statement_type *script_file = 0;
-boolean option_longmap = false;
lang_statement_list_type file_chain =
{0};
CONST char *entry_symbol = 0;
/* IMPORTS */
extern char *default_target;
-extern unsigned int undefined_global_sym_count;
extern char *current_file;
extern bfd *output_bfd;
extern enum bfd_architecture ldfile_output_architecture;
extern unsigned int commons_pending;
extern args_type command_line;
extern ld_config_type config;
-extern boolean had_script;
extern boolean write_map;
+extern int g_switch_value;
+
+
+etree_type *base; /* Relocation base - or null */
+
#ifdef __STDC__
#define cat(a,b) a##b
#define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
-void EXFUN (lang_add_data, (int type, union etree_union * exp));
+void lang_add_data PARAMS ((int type, union etree_union * exp));
PTR
-DEFUN (stat_alloc, (size),
- size_t size)
+stat_alloc (size)
+ size_t size;
{
return obstack_alloc (&stat_obstack, size);
}
static void
-DEFUN (print_size, (value),
- size_t value)
+print_size (value)
+ size_t value;
{
fprintf (config.map_file, "%5x", (unsigned) value);
}
static void
-DEFUN (print_alignment, (value),
- unsigned int value)
+print_alignment (value)
+ unsigned int value;
{
fprintf (config.map_file, "2**%1u", value);
}
static void
DEFUN (print_fill, (value),
- fill_type value)
+ fill_type value)
{
fprintf (config.map_file, "%04x", (unsigned) value);
}
static void
-DEFUN (print_section, (name),
- CONST char *CONST name)
+print_section (name)
+ CONST char *CONST name;
{
fprintf (config.map_file, "%*s", -longest_section_name, name);
}
*/
static void
-DEFUN (lang_for_each_statement_worker, (func, s),
- void (*func) ()AND
- lang_statement_union_type * s)
+lang_for_each_statement_worker (func, s)
+ void (*func) ();
+ lang_statement_union_type *s;
{
for (; s != (lang_statement_union_type *) NULL; s = s->next)
{
}
void
-DEFUN (lang_for_each_statement, (func),
- void (*func) ())
+lang_for_each_statement (func)
+ void (*func) ();
{
lang_for_each_statement_worker (func,
statement_list.head);
/*----------------------------------------------------------------------*/
void
-DEFUN (lang_list_init, (list),
- lang_statement_list_type * list)
+lang_list_init (list)
+ lang_statement_list_type *list;
{
list->head = (lang_statement_union_type *) NULL;
list->tail = &list->head;
static
lang_statement_union_type *
-DEFUN (new_statement, (type, size, list),
- enum statement_enum type AND
- bfd_size_type size AND
- lang_statement_list_type * list)
+new_statement (type, size, list)
+ enum statement_enum type;
+ size_t size;
+ lang_statement_list_type * list;
{
lang_statement_union_type *new = (lang_statement_union_type *)
stat_alloc (size);
*/
static lang_input_statement_type *
-DEFUN (new_afile, (name, file_type, target),
- CONST char *CONST name AND
- CONST lang_input_file_enum_type file_type AND
- CONST char *CONST target)
+new_afile (name, file_type, target)
+ CONST char *CONST name;
+ CONST lang_input_file_enum_type file_type;
+ CONST char *CONST target;
{
lang_input_statement_type *p = new_stat (lang_input_statement,
}
lang_input_statement_type *
-DEFUN (lang_add_input_file, (name, file_type, target),
- CONST char *name AND
- lang_input_file_enum_type file_type AND
- CONST char *target)
+lang_add_input_file (name, file_type, target)
+ CONST char *name;
+ lang_input_file_enum_type file_type;
+ CONST char *target;
{
/* Look it up or build a new one */
lang_has_input_file = true;
+
+ if (name) {
+ if ((*(name+strlen(name)-1) == '.') && (*(name+strlen(name)) == 'a')) {
+ file_type=lang_input_file_is_l_enum;
+ }
+ }
+
#if 0
lang_input_statement_type *p;
return new_afile (name, file_type, target);
}
+void
+lang_add_keepsyms_file (filename)
+ CONST char *filename;
+{
+ extern strip_symbols_type strip_symbols;
+ if (keepsyms_file != 0)
+ info_msg ("%X%P: error: duplicated keep-symbols-file value\n");
+ keepsyms_file = filename;
+ if (strip_symbols != STRIP_NONE)
+ info_msg ("%P: `-keep-only-symbols-file' overrides `-s' and `-S'\n");
+ strip_symbols = STRIP_SOME;
+}
+
/* Build enough state so that the parser can build its tree */
void
-DEFUN_VOID (lang_init)
+lang_init ()
{
obstack_begin (&stat_obstack, 1000);
static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
lang_memory_region_type *
-DEFUN (lang_memory_region_lookup, (name),
- CONST char *CONST name)
+lang_memory_region_lookup (name)
+ CONST char *CONST name;
{
lang_memory_region_type *p = lang_memory_region_list;
*lang_memory_region_list_tail = new;
lang_memory_region_list_tail = &new->next;
new->origin = 0;
- new->length = ~0;
+ new->length = ~(bfd_size_type)0;
new->current = 0;
new->had_full_message = false;
lang_output_section_statement_type *
-DEFUN (lang_output_section_find, (name),
- CONST char *CONST name)
+lang_output_section_find (name)
+ CONST char *CONST name;
{
lang_statement_union_type *u;
lang_output_section_statement_type *lookup;
}
lang_output_section_statement_type *
-DEFUN (lang_output_section_statement_lookup, (name),
- CONST char *CONST name)
+lang_output_section_statement_lookup (name)
+ CONST char *CONST name;
{
lang_output_section_statement_type *lookup;
lookup->next = (lang_statement_union_type *) NULL;
lookup->bfd_section = (asection *) NULL;
lookup->processed = false;
+ lookup->loadable = 1;
lookup->addr_tree = (etree_type *) NULL;
lang_list_init (&lookup->children);
+ lookup->memspec = (CONST char *) NULL;
+ lookup->flags = 0;
+ lookup->subsection_alignment = -1;
+ lookup->section_alignment = -1;
+ lookup->load_base = (union etree_union *) NULL;
+
lang_statement_append (&lang_output_section_statement,
(lang_statement_union_type *) lookup,
&lookup->next);
/*ARGSUSED*/
static void
-DEFUN (print_flags, (ignore_flags),
- int *ignore_flags)
+print_flags (ignore_flags)
+ int *ignore_flags;
{
fprintf (config.map_file, "(");
#if 0
if (flags->flag_loadable)
fprintf (outfile, "L");
#endif
- fprintf (config.map_file, ")");
+ fprintf (config.map_file, ")");
}
void
-DEFUN_VOID (lang_map)
+lang_map ()
{
lang_memory_region_type *m;
#ifdef HOST_64_BIT
fprintf (config.map_file, "name\t\torigin\t\tlength\t\tattributes\n");
#else
- fprintf (config.map_file, "name\t\torigin length\t\tattributes\n");
+ fprintf (config.map_file,
+ "name\t\torigin length r_size c_size is attributes\n");
+
#endif
for (m = lang_memory_region_list;
m != (lang_memory_region_type *) NULL;
fprintf (config.map_file, "%-16s", m->name);
print_address (m->origin);
print_space ();
- print_address (m->length);
+ print_address ((bfd_vma)m->length);
print_space ();
+ print_address ((bfd_vma)m->old_length);
+ print_space();
+ print_address (m->current - m->origin);
+ print_space();
+ if (m->old_length)
+ fprintf(config.map_file," %2d%% ", ( m->current - m->origin) * 100 / m->old_length);
print_flags (&m->flags);
fprintf (config.map_file, "\n");
}
*
*/
static void
-DEFUN (init_os, (s),
- lang_output_section_statement_type * s)
+init_os (s)
+ lang_output_section_statement_type * s;
{
/* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
section_userdata_type *new =
s->bfd_section = bfd_make_section (output_bfd, s->name);
if (s->bfd_section == (asection *) NULL)
{
- einfo ("%P%F output format %s cannot represent section called %s\n",
+ einfo ("%P%F: output format %s cannot represent section called %s\n",
output_bfd->xvec->name, s->name);
}
s->bfd_section->output_section = s->bfd_section;
- /* s->bfd_section->flags = s->flags;*/
+/* s->bfd_section->flags = s->flags;*/
/* We initialize an output sections output offset to minus its own */
/* vma to allow us to output a section through itself */
*/
static void
-DEFUN (wild_doit, (ptr, section, output, file),
- lang_statement_list_type * ptr AND
- asection * section AND
- lang_output_section_statement_type * output AND
- lang_input_statement_type * file)
+wild_doit (ptr, section, output, file)
+ lang_statement_list_type * ptr;
+ asection * section;
+ lang_output_section_statement_type * output;
+ lang_input_statement_type * file;
{
if (output->bfd_section == (asection *) NULL)
+ {
+ init_os (output);
+ /* Initialize the vma and size to the existing section. This will
+ be overriden in lang_size_sections unless SEC_NEVER_LOAD gets
+ set. */
+ if (section != (asection *) NULL)
{
- init_os (output);
+ bfd_set_section_vma (0, output->bfd_section,
+ bfd_section_vma (0, section));
+ output->bfd_section->_raw_size = section->_raw_size;
}
+ }
if (section != (asection *) NULL
&& section->output_section == (asection *) NULL)
- {
- /* Add a section reference to the list */
- lang_input_section_type *new = new_stat (lang_input_section, ptr);
+ {
+ /* Add a section reference to the list */
+ lang_input_section_type *new = new_stat (lang_input_section, ptr);
- new->section = section;
- new->ifile = file;
- section->output_section = output->bfd_section;
+ new->section = section;
+ new->ifile = file;
+ section->output_section = output->bfd_section;
+
+ /* Be selective about what the output section inherits from the
+ input section */
+
+ if ((section->flags & SEC_SHARED_LIBRARY) != 0)
section->output_section->flags |= section->flags;
- if (section->alignment_power > output->bfd_section->alignment_power)
- {
- output->bfd_section->alignment_power = section->alignment_power;
- }
+ else
+ section->output_section->flags |= section->flags & ~SEC_NEVER_LOAD;
+
+ if (!output->loadable)
+ {
+ /* Turn off load flag */
+ output->bfd_section->flags &= ~SEC_LOAD;
+ output->bfd_section->flags |= SEC_NEVER_LOAD;
}
+ if (section->alignment_power > output->bfd_section->alignment_power)
+ {
+ output->bfd_section->alignment_power = section->alignment_power;
+ }
+ /* If supplied an aligmnet, then force it */
+ if (output->section_alignment != -1)
+ {
+ output->bfd_section->alignment_power = output->section_alignment;
+ }
+ }
}
static asection *
-DEFUN (our_bfd_get_section_by_name, (abfd, section),
- bfd * abfd AND
- CONST char *section)
+our_bfd_get_section_by_name (abfd, section)
+ bfd * abfd;
+ CONST char *section;
{
return bfd_get_section_by_name (abfd, section);
}
static void
-DEFUN (wild_section, (ptr, section, file, output),
- lang_wild_statement_type * ptr AND
- CONST char *section AND
- lang_input_statement_type * file AND
- lang_output_section_statement_type * output)
+wild_section (ptr, section, file, output)
+ lang_wild_statement_type * ptr;
+ CONST char *section;
+ lang_input_statement_type * file;
+ lang_output_section_statement_type * output;
{
asection *s;
{
/* Do the creation to all sections in the file */
for (s = file->the_bfd->sections; s != (asection *) NULL; s = s->next)
+ {
+ /* except for bss */
+ if ((s->flags & SEC_IS_COMMON) == 0)
{
wild_doit (&ptr->children, s, output, file);
}
+ }
}
else
{
*/
static
lang_input_statement_type *
-DEFUN (lookup_name, (name),
- CONST char *CONST name)
+lookup_name (name)
+ CONST char *CONST name;
{
lang_input_statement_type *search;
}
static void
-DEFUN (wild, (s, section, file, target, output),
- lang_wild_statement_type * s AND
- CONST char *CONST section AND
- CONST char *CONST file AND
- CONST char *CONST target AND
- lang_output_section_statement_type * output)
+wild (s, section, file, target, output)
+ lang_wild_statement_type * s;
+ CONST char *CONST section;
+ CONST char *CONST file;
+ CONST char *CONST target;
+ lang_output_section_statement_type * output;
{
lang_input_statement_type *f;
{
wild_section (s, section, f, output);
}
+ /* Once more for the script file */
+ wild_section(s, section, script_file, output);
}
else
{
read in all the files
*/
static bfd *
-DEFUN (open_output, (name),
- CONST char *CONST name)
+open_output (name)
+ CONST char *CONST name;
{
+ extern unsigned long ldfile_output_machine;
+ extern enum bfd_architecture ldfile_output_architecture;
+
extern CONST char *output_filename;
bfd *output;
{
if (bfd_error == invalid_target)
{
- einfo ("%P%F target %s not found\n", output_target);
+ einfo ("%P%F: target %s not found\n", output_target);
}
- einfo ("%P%F problem opening output file %s, %E", name);
+ einfo ("%P%F: cannot open output file %s: %E\n", name);
}
-/* output->flags |= D_PAGED;*/
- bfd_set_format (output, bfd_object);
+ /* output->flags |= D_PAGED;*/
+
+ if (! bfd_set_format (output, bfd_object))
+ einfo ("%P%F:%s: can not make object file: %E\n", name);
+ if (! bfd_set_arch_mach (output,
+ ldfile_output_architecture,
+ ldfile_output_machine))
+ einfo ("%P%F:%s: can not set architecture: %E\n", name);
+
+ bfd_set_gp_size (output, g_switch_value);
return output;
}
static void
-DEFUN (ldlang_open_output, (statement),
- lang_statement_union_type * statement)
+ldlang_open_output (statement)
+ lang_statement_union_type * statement;
{
switch (statement->header.type)
{
}
static void
-DEFUN (open_input_bfds, (statement),
- lang_statement_union_type * statement)
+open_input_bfds (statement)
+ lang_statement_union_type * statement;
{
switch (statement->header.type)
{
static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
void
-DEFUN (ldlang_add_undef, (name),
- CONST char *CONST name)
+ldlang_add_undef (name)
+ CONST char *CONST name;
{
ldlang_undef_chain_list_type *new =
(ldlang_undef_chain_list_type
script file.
*/
static void
-DEFUN_VOID (lang_place_undefineds)
+lang_place_undefineds ()
{
ldlang_undef_chain_list_type *ptr = ldlang_undef_chain_list_head;
*def_ptr = def;
def->name = ptr->name;
def->section = &bfd_und_section;
- Q_enter_global_ref (def_ptr, ptr->name);
+ enter_global_ref (def_ptr, ptr->name);
ptr = ptr->next;
}
}
*/
static void
-DEFUN_VOID (lang_create_output_section_statements)
+lang_create_output_section_statements ()
{
lang_statement_union_type *os;
}
static void
-DEFUN_VOID (lang_init_script_file)
+lang_init_script_file ()
{
- script_file = lang_add_input_file ("script file",
+ script_file = lang_add_input_file ("command line",
lang_input_file_is_fake_enum,
(char *) NULL);
- script_file->the_bfd = bfd_create ("script file", output_bfd);
+ script_file->the_bfd = bfd_create ("command line", output_bfd);
script_file->symbol_count = 0;
- script_file->the_bfd->sections = output_bfd->sections;
- abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
+ script_file->the_bfd->sections = 0;
+
+ /* The user data of a bfd points to the input statement attatched */
+ script_file->the_bfd->usrdata = (void *)script_file;
+ script_file->common_section =
+ bfd_make_section(script_file->the_bfd,"COMMON");
+
+ abs_output_section =
+ lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
abs_output_section->bfd_section = &bfd_abs_section;
/* Open input files and attatch to output sections */
static void
-DEFUN (map_input_to_output_sections, (s, target, output_section_statement),
- lang_statement_union_type * s AND
- CONST char *target AND
- lang_output_section_statement_type * output_section_statement)
+map_input_to_output_sections (s, target, output_section_statement)
+ lang_statement_union_type * s;
+ CONST char *target;
+ lang_output_section_statement_type * output_section_statement;
{
for (; s != (lang_statement_union_type *) NULL; s = s->next)
{
os->addr_tree = s->address_statement.address;
if (os->bfd_section == (asection *) NULL)
{
- einfo ("%P%F can't set the address of undefined section %s\n",
+ einfo ("%P%F: cannot set the address of undefined section %s\n",
s->address_statement.section_name);
}
}
static void
-DEFUN (print_output_section_statement, (output_section_statement),
- lang_output_section_statement_type * output_section_statement)
+print_output_section_statement (output_section_statement)
+ lang_output_section_statement_type * output_section_statement;
{
asection *section = output_section_statement->bfd_section;
print_nl ();
print_section (output_section_statement->name);
+
if (section)
- {
- print_dot = section->vma;
- print_space ();
- print_section ("");
- print_space ();
- print_address (section->vma);
- print_space ();
- print_size (bfd_get_section_size_before_reloc (section));
- print_space ();
- print_alignment (section->alignment_power);
- print_space ();
+ {
+ print_dot = section->vma;
+ print_space ();
+ print_section ("");
+ print_space ();
+ print_address (section->vma);
+ print_space ();
+ print_size (section->_raw_size);
+ print_space();
+ print_size(section->_cooked_size);
+ print_space ();
+ print_alignment (section->alignment_power);
+ print_space ();
#if 0
- fprintf (config.map_file, "%s flags", output_section_statement->region->name);
- print_flags (stdout, &output_section_statement->flags);
+ fprintf (config.map_file, "%s flags", output_section_statement->region->name);
+ print_flags (stdout, &output_section_statement->flags);
#endif
- if (section->flags & SEC_LOAD)
- fprintf (config.map_file, "load ");
- if (section->flags & SEC_ALLOC)
- fprintf (config.map_file, "alloc ");
- if (section->flags & SEC_RELOC)
- fprintf (config.map_file, "reloc ");
- if (section->flags & SEC_HAS_CONTENTS)
- fprintf (config.map_file, "contents ");
+ if (section->flags & SEC_LOAD)
+ fprintf (config.map_file, "load ");
+ if (section->flags & SEC_ALLOC)
+ fprintf (config.map_file, "alloc ");
+ if (section->flags & SEC_RELOC)
+ fprintf (config.map_file, "reloc ");
+ if (section->flags & SEC_HAS_CONTENTS)
+ fprintf (config.map_file, "contents ");
- }
+ }
else
+ {
+ fprintf (config.map_file, "No attached output section");
+ }
+ print_nl ();
+ if (output_section_statement->load_base)
{
- fprintf (config.map_file, "No attached output section");
+ int b = exp_get_value_int(output_section_statement->load_base,
+ 0, "output base", lang_final_phase_enum);
+ printf("Output address %08x\n", b);
}
- print_nl ();
+ if (output_section_statement->section_alignment >= 0
+ || output_section_statement->section_alignment >= 0)
+ {
+ printf("\t\t\t\t\tforced alignment ");
+ if ( output_section_statement->section_alignment >= 0)
+ {
+ printf("section 2**%d ",output_section_statement->section_alignment );
+ }
+ if ( output_section_statement->subsection_alignment >= 0)
+ {
+ printf("subsection 2**%d ",output_section_statement->subsection_alignment );
+ }
+
+ print_nl ();
+ }
print_statement (output_section_statement->children.head,
output_section_statement);
}
static void
-DEFUN (print_assignment, (assignment, output_section),
- lang_assignment_statement_type * assignment AND
- lang_output_section_statement_type * output_section)
+print_assignment (assignment, output_section)
+ lang_assignment_statement_type * assignment;
+ lang_output_section_statement_type * output_section;
{
etree_value_type result;
}
static void
-DEFUN (print_input_statement, (statm),
- lang_input_statement_type * statm)
+print_input_statement (statm)
+ lang_input_statement_type * statm;
{
if (statm->filename != (char *) NULL)
{
}
static void
-DEFUN (print_symbol, (q),
- asymbol * q)
+print_symbol (q)
+ asymbol * q;
{
print_section ("");
fprintf (config.map_file, " ");
fprintf (config.map_file, " ");
print_address (outside_symbol_address (q));
fprintf (config.map_file, " %s", q->name ? q->name : " ");
+ if (q->flags & BSF_WEAK)
+ fprintf (config.map_file, " *weak*");
print_nl ();
}
static void
-DEFUN (print_input_section, (in),
- lang_input_section_type * in)
+print_input_section (in)
+ lang_input_section_type * in;
{
asection *i = in->section;
int size = i->reloc_done ?
{
print_address (i->output_section->vma + i->output_offset);
fprintf (config.map_file, " ");
- print_size (size);
+ print_size (i->_raw_size);
+ fprintf (config.map_file, " ");
+ print_size(i->_cooked_size);
fprintf (config.map_file, " ");
print_alignment (i->alignment_power);
fprintf (config.map_file, " ");
/* Find all the symbols in this file defined in this section */
- if (in->ifile->symbol_count)
- {
- asymbol **p;
+ if (in->ifile->symbol_count)
+ {
+ asymbol **p;
- for (p = in->ifile->asymbols; *p; p++)
- {
- asymbol *q = *p;
+ for (p = in->ifile->asymbols; *p; p++)
+ {
+ asymbol *q = *p;
- if (bfd_get_section (q) == i && q->flags & BSF_GLOBAL)
- {
- print_symbol (q);
- }
- }
- }
+ if (bfd_get_section (q) == i
+ && (q->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
+ {
+ print_symbol (q);
+ }
+ }
+ }
}
else
{
}
static void
-DEFUN (print_fill_statement, (fill),
- lang_fill_statement_type * fill)
+print_fill_statement (fill)
+ lang_fill_statement_type * fill;
{
fprintf (config.map_file, "FILL mask ");
print_fill (fill->fill);
}
static void
-DEFUN (print_data_statement, (data),
- lang_data_statement_type * data)
+print_data_statement (data)
+ lang_data_statement_type * data;
{
/* bfd_vma value; */
print_section ("");
static void
-DEFUN (print_padding_statement, (s),
- lang_padding_statement_type * s)
+print_padding_statement (s)
+ lang_padding_statement_type * s;
{
print_section ("");
print_space ();
}
static void
-DEFUN (print_wild_statement, (w, os),
- lang_wild_statement_type * w AND
- lang_output_section_statement_type * os)
+print_wild_statement (w, os)
+ lang_wild_statement_type * w;
+ lang_output_section_statement_type * os;
{
fprintf (config.map_file, " from ");
if (w->filename != (char *) NULL)
}
static void
-DEFUN (print_statement, (s, os),
- lang_statement_union_type * s AND
- lang_output_section_statement_type * os)
+print_statement (s, os)
+ lang_statement_union_type * s;
+ lang_output_section_statement_type * os;
{
while (s)
{
case lang_output_statement_enum:
fprintf (config.map_file, "OUTPUT(%s %s)\n",
s->output_statement.name,
- output_target);
+ output_target ? output_target : "");
break;
case lang_input_statement_enum:
print_input_statement (&s->input_statement);
static void
-DEFUN_VOID (print_statements)
+print_statements ()
{
print_statement (statement_list.head,
abs_output_section);
static bfd_vma
DEFUN (insert_pad, (this_ptr, fill, power, output_section_statement, dot),
- lang_statement_union_type ** this_ptr AND
- fill_type fill AND
- unsigned int power AND
- asection * output_section_statement AND
- bfd_vma dot)
+ lang_statement_union_type ** this_ptr AND
+ fill_type fill AND
+ unsigned int power AND
+ asection * output_section_statement AND
+ bfd_vma dot)
{
/* Align this section first to the
input sections requirement, then
/* Work out how much this section will move the dot point */
static bfd_vma
-DEFUN (size_input_section, (this_ptr, output_section_statement, fill, dot),
- lang_statement_union_type ** this_ptr AND
- lang_output_section_statement_type * output_section_statement AND
- unsigned short fill AND
- bfd_vma dot)
+DEFUN (size_input_section, (this_ptr, output_section_statement, fill, dot, relax),
+ lang_statement_union_type ** this_ptr AND
+ lang_output_section_statement_type * output_section_statement AND
+ unsigned short fill AND
+ bfd_vma dot AND
+ boolean relax)
{
lang_input_section_type *is = &((*this_ptr)->input_section);
asection *i = is->section;
if (is->ifile->just_syms_flag == false)
{
+ if (output_section_statement->subsection_alignment != -1)
+ i->alignment_power =
+ output_section_statement->subsection_alignment;
+
dot = insert_pad (this_ptr, fill, i->alignment_power,
output_section_statement->bfd_section, dot);
/* remember the largest size so we can malloc the largest area
needed for the output stage. Only remember the size of sections
which we will actually allocate */
- if (((i->flags &
- (SEC_HAS_CONTENTS | SEC_LOAD)) == (SEC_HAS_CONTENTS | SEC_LOAD))
+ if ((i->flags & SEC_HAS_CONTENTS) != 0
&& (bfd_get_section_size_before_reloc (i) > largest_section))
{
largest_section = bfd_get_section_size_before_reloc (i);
i->output_offset = dot - output_section_statement->bfd_section->vma;
- /* Mark how big the output section must be to contain this now */
- dot += bfd_get_section_size_before_reloc (i);
- output_section_statement->bfd_section->_raw_size =
- dot - output_section_statement->bfd_section->vma;
+ /* Mark how big the output section must be to contain this now
+ */
+ if (relax)
+ {
+ dot += i->_cooked_size;
+ }
+ else
+ {
+ dot += i->_raw_size;
+ }
+ output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
}
else
{
static boolean had_relax;
static bfd_vma
-DEFUN (lang_size_sections, (s, output_section_statement, prev, fill,
- dot, relax),
- lang_statement_union_type * s AND
- lang_output_section_statement_type * output_section_statement AND
- lang_statement_union_type ** prev AND
- unsigned short fill AND
- bfd_vma dot AND
- boolean relax)
+DEFUN (lang_size_sections, (s, output_section_statement, prev, fill, dot, relax),
+ lang_statement_union_type * s AND
+ lang_output_section_statement_type * output_section_statement AND
+ lang_statement_union_type ** prev AND
+ unsigned short fill AND
+ bfd_vma dot AND
+ boolean relax)
{
/* Size up the sections from their constituent parts */
for (; s != (lang_statement_union_type *) NULL; s = s->next)
+ {
+ switch (s->header.type)
{
- switch (s->header.type)
- {
-
- case lang_output_section_statement_enum:
- {
- bfd_vma after;
- lang_output_section_statement_type *os = &s->output_section_statement;
-
- if (os->bfd_section == &bfd_abs_section)
- {
- /* No matter what happens, an abs section starts at zero */
- os->bfd_section->vma = 0;
- }
- else
- {
- if (os->addr_tree == (etree_type *) NULL)
- {
- /* No address specified for this section, get one
- from the region specification
- */
- if (os->region == (lang_memory_region_type *) NULL)
- {
- os->region = lang_memory_region_lookup ("*default*");
- }
- dot = os->region->current;
- }
- else
- {
- etree_value_type r;
-
- r = exp_fold_tree (os->addr_tree,
- abs_output_section,
- lang_allocating_phase_enum,
- dot, &dot);
- if (r.valid == false)
- {
- einfo ("%F%S: non constant address expression for section %s\n",
- os->name);
- }
- dot = r.value;
- }
- /* The section starts here */
- /* First, align to what the section needs */
-
-
- dot = align_power (dot, os->bfd_section->alignment_power);
- os->bfd_section->vma = dot;
- }
+ case lang_output_section_statement_enum:
+ {
+ bfd_vma after;
+ lang_output_section_statement_type *os = &s->output_section_statement;
+
+ /* If this is a shared library section, don't change the size
+ and address. */
+ if (os->bfd_section->flags & SEC_SHARED_LIBRARY)
+ break;
+
+ if (os->bfd_section == &bfd_abs_section)
+ {
+ /* No matter what happens, an abs section starts at zero */
+ bfd_set_section_vma (0, os->bfd_section, 0);
+ }
+ else
+ {
+ if (os->addr_tree == (etree_type *) NULL)
+ {
+ /* No address specified for this section, get one
+ from the region specification
+ */
+ if (os->region == (lang_memory_region_type *) NULL)
+ {
+ os->region = lang_memory_region_lookup ("*default*");
+ }
+ dot = os->region->current;
+ }
+ else
+ {
+ etree_value_type r;
+
+ r = exp_fold_tree (os->addr_tree,
+ abs_output_section,
+ lang_allocating_phase_enum,
+ dot, &dot);
+ if (r.valid == false)
+ {
+ einfo ("%F%S: non constant address expression for section %s\n",
+ os->name);
+ }
+ dot = r.value;
+ }
+ /* The section starts here */
+ /* First, align to what the section needs */
+
+
+ dot = align_power (dot, os->bfd_section->alignment_power);
+ bfd_set_section_vma (0, os->bfd_section, dot);
+
+ if (os->load_base) {
+ os->bfd_section->lma
+ = exp_get_value_int(os->load_base, 0,"load base", lang_final_phase_enum);
+ }
+ }
+
+
+ os->bfd_section->output_offset = 0;
+
+ (void) lang_size_sections (os->children.head, os, &os->children.head,
+ os->fill, dot, relax);
+ /* Ignore the size of the input sections, use the vma and size to */
+ /* align against */
+
+
+ after = ALIGN_N (os->bfd_section->vma +
+ os->bfd_section->_raw_size,
+ os->block_value);
+
+
+ os->bfd_section->_raw_size = after - os->bfd_section->vma;
+ dot = os->bfd_section->vma + os->bfd_section->_raw_size;
+ os->processed = true;
+
+ /* Replace into region ? */
+ if (os->addr_tree == (etree_type *) NULL
+ && os->region != (lang_memory_region_type *) NULL)
+ {
+ os->region->current = dot;
+ /* Make sure this isn't silly */
+ if (( os->region->current
+ > os->region->origin + os->region->length)
+ || ( os->region->origin > os->region->current ))
+ {
+ einfo ("%X%P: region %s is full (%B section %s)\n",
+ os->region->name,
+ os->bfd_section->owner,
+ os->bfd_section->name);
+ /* Reset the region pointer */
+ os->region->current = 0;
+
+ }
+
+ }
+ }
- os->bfd_section->output_offset = 0;
-
- (void) lang_size_sections (os->children.head, os, &os->children.head,
- os->fill, dot, relax);
- /* Ignore the size of the input sections, use the vma and size to */
- /* align against */
-
-
- after = ALIGN (os->bfd_section->vma +
- os->bfd_section->_raw_size,
- os->block_value);
-
-
- os->bfd_section->_raw_size = after - os->bfd_section->vma;
- dot = os->bfd_section->vma + os->bfd_section->_raw_size;
- os->processed = true;
-
- /* Replace into region ? */
- if (os->addr_tree == (etree_type *) NULL
- && os->region != (lang_memory_region_type *) NULL)
- {
- os->region->current = dot;
- /* Make sure this isn't silly */
- if (os->region->current >
- os->region->origin +
- os->region->length)
- {
- einfo ("%X%P: Region %s is full (%B section %s)\n",
- os->region->name,
- os->bfd_section->owner,
- os->bfd_section->name);
- /* Reset the region pointer */
- os->region->current = 0;
-
- }
-
- }
- }
-
- break;
- case lang_constructors_statement_enum:
- dot = lang_size_sections (constructor_list.head,
- output_section_statement,
- &s->wild_statement.children.head,
- fill,
- dot, relax);
- break;
-
- case lang_data_statement_enum:
- {
- unsigned int size = 0;
-
- s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
- s->data_statement.output_section =
- output_section_statement->bfd_section;
-
- switch (s->data_statement.type)
- {
- case LONG:
- size = LONG_SIZE;
- break;
- case SHORT:
- size = SHORT_SIZE;
- break;
- case BYTE:
- size = BYTE_SIZE;
- break;
-
- }
- dot += size;
- output_section_statement->bfd_section->_raw_size += size;
- }
- break;
-
- case lang_wild_statement_enum:
+ break;
+ case lang_constructors_statement_enum:
+ dot = lang_size_sections (constructor_list.head,
+ output_section_statement,
+ &s->wild_statement.children.head,
+ fill,
+ dot, relax);
+ break;
- dot = lang_size_sections (s->wild_statement.children.head,
- output_section_statement,
- &s->wild_statement.children.head,
+ case lang_data_statement_enum:
+ {
+ unsigned int size = 0;
+
+ s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
+ s->data_statement.output_section =
+ output_section_statement->bfd_section;
+
+ switch (s->data_statement.type)
+ {
+ case LONG:
+ size = LONG_SIZE;
+ break;
+ case SHORT:
+ size = SHORT_SIZE;
+ break;
+ case BYTE:
+ size = BYTE_SIZE;
+ break;
+
+ }
+ dot += size;
+ output_section_statement->bfd_section->_raw_size += size;
+ }
+ break;
- fill, dot, relax);
+ case lang_wild_statement_enum:
- break;
+ dot = lang_size_sections (s->wild_statement.children.head,
+ output_section_statement,
+ &s->wild_statement.children.head,
- case lang_object_symbols_statement_enum:
- create_object_symbols = output_section_statement;
- break;
- case lang_output_statement_enum:
- case lang_target_statement_enum:
- break;
- case lang_input_section_enum:
- if (relax)
- {
- relaxing = true;
+ fill, dot, relax);
- had_relax = had_relax || relax_section (prev);
- relaxing = false;
+ break;
- }
+ case lang_object_symbols_statement_enum:
+ create_object_symbols = output_section_statement;
+ break;
+ case lang_output_statement_enum:
+ case lang_target_statement_enum:
+ break;
+ case lang_input_section_enum:
+ if (relax)
+ {
+ relaxing = true;
- dot = size_input_section (prev,
- output_section_statement,
- output_section_statement->fill, dot);
- break;
- case lang_input_statement_enum:
- break;
- case lang_fill_statement_enum:
- s->fill_statement.output_section = output_section_statement->bfd_section;
+ if( relax_section (prev))
+ had_relax = true;
+ relaxing = false;
- fill = s->fill_statement.fill;
- break;
- case lang_assignment_statement_enum:
- {
- bfd_vma newdot = dot;
+ }
+ else {
+ (*prev)->input_section.section->_cooked_size =
+ (*prev)->input_section.section->_raw_size ;
- exp_fold_tree (s->assignment_statement.exp,
- output_section_statement,
- lang_allocating_phase_enum,
- dot,
- &newdot);
+ }
+ dot = size_input_section (prev,
+ output_section_statement,
+ output_section_statement->fill,
+ dot, relax);
+ break;
+ case lang_input_statement_enum:
+ break;
+ case lang_fill_statement_enum:
+ s->fill_statement.output_section = output_section_statement->bfd_section;
- if (newdot != dot && !relax)
- /* We've been moved ! so insert a pad */
- {
- lang_statement_union_type *new =
- (lang_statement_union_type *)
- stat_alloc ((bfd_size_type) (sizeof (lang_padding_statement_type)));
-
- /* Link into existing chain */
- new->header.next = *prev;
- *prev = new;
- new->header.type = lang_padding_statement_enum;
- new->padding_statement.output_section =
- output_section_statement->bfd_section;
- new->padding_statement.output_offset =
- dot - output_section_statement->bfd_section->vma;
- new->padding_statement.fill = fill;
- new->padding_statement.size = newdot - dot;
- output_section_statement->bfd_section->_raw_size +=
- new->padding_statement.size;
- dot = newdot;
- }
- }
+ fill = s->fill_statement.fill;
+ break;
+ case lang_assignment_statement_enum:
+ {
+ bfd_vma newdot = dot;
+
+ exp_fold_tree (s->assignment_statement.exp,
+ output_section_statement,
+ lang_allocating_phase_enum,
+ dot,
+ &newdot);
+
+ if (newdot != dot && !relax)
+ /* We've been moved ! so insert a pad */
+ {
+ lang_statement_union_type *new =
+ (lang_statement_union_type *)
+ stat_alloc ((bfd_size_type) (sizeof (lang_padding_statement_type)));
+
+ /* Link into existing chain */
+ new->header.next = *prev;
+ *prev = new;
+ new->header.type = lang_padding_statement_enum;
+ new->padding_statement.output_section =
+ output_section_statement->bfd_section;
+ new->padding_statement.output_offset =
+ dot - output_section_statement->bfd_section->vma;
+ new->padding_statement.fill = fill;
+ new->padding_statement.size = newdot - dot;
+ output_section_statement->bfd_section->_raw_size +=
+ new->padding_statement.size;
+ dot = newdot;
+ }
+ }
- break;
- default:
- FAIL ();
- break;
- /* This can only get here when relaxing is turned on */
- case lang_padding_statement_enum:
+ break;
+ default:
+ FAIL ();
+ break;
+ /* This can only get here when relaxing is turned on */
+ case lang_padding_statement_enum:
- case lang_address_statement_enum:
- break;
- }
- prev = &s->header.next;
+ case lang_address_statement_enum:
+ break;
}
+ prev = &s->header.next;
+ }
return dot;
}
static bfd_vma
DEFUN (lang_do_assignments, (s, output_section_statement, fill, dot),
- lang_statement_union_type * s AND
- lang_output_section_statement_type * output_section_statement AND
- unsigned short fill AND
- bfd_vma dot)
+ lang_statement_union_type * s AND
+ lang_output_section_statement_type * output_section_statement AND
+ unsigned short fill AND
+ bfd_vma dot)
{
for (; s != (lang_statement_union_type *) NULL; s = s->next)
lang_final_phase_enum, dot, &dot);
s->data_statement.value = value.value;
if (value.valid == false)
- einfo ("%F%P: Invalid data statement\n");
+ einfo ("%F%P: invalid data statement\n");
}
switch (s->data_statement.type)
{
static void
-DEFUN_VOID (lang_relocate_globals)
+lang_relocate_globals ()
{
-
/*
Each ldsym_type maintains a chain of pointers to asymbols which
references the definition. Replace each pointer to the referenence
{
asymbol *it;
+ /* Skip indirect symbols. */
+ if (lgs->flags & SYM_INDIRECT)
+ continue;
+
if (lgs->sdefs_chain)
{
it = *(lgs->sdefs_chain);
}
if (it != (asymbol *) NULL)
{
+ asymbol **prev = 0;
asymbol **ptr = lgs->srefs_chain;;
if (lgs->flags & SYM_WARNING)
{
produce_warnings (lgs, it);
}
- while (ptr != (asymbol **) NULL)
+ while (ptr != (asymbol **) NULL
+ && ptr != prev)
{
asymbol *ref = *ptr;
-
+ prev = ptr;
*ptr = it;
ptr = (asymbol **) (ref->udata);
}
static void
-DEFUN_VOID (lang_finish)
+lang_finish ()
{
ldsym_type *lgs;
-
+ int warn = config.relocateable_output != true;
if (entry_symbol == (char *) NULL)
- {
- /* No entry has been specified, look for start */
- entry_symbol = "start";
- }
+ {
+ /* No entry has been specified, look for start, but don't warn */
+ entry_symbol = "start";
+ warn =0;
+ }
lgs = ldsym_get_soft (entry_symbol);
if (lgs && lgs->sdefs_chain)
- {
- asymbol *sy = *(lgs->sdefs_chain);
+ {
+ asymbol *sy = *(lgs->sdefs_chain);
- /* We can set the entry address*/
- bfd_set_start_address (output_bfd,
- outside_symbol_address (sy));
+ /* We can set the entry address*/
+ bfd_set_start_address (output_bfd,
+ outside_symbol_address (sy));
- }
+ }
else
+ {
+ /* Cannot find anything reasonable,
+ use the first address in the text section
+ */
+ asection *ts = bfd_get_section_by_name (output_bfd, ".text");
+ if (ts)
{
- /* Can't find anything reasonable,
- use the first address in the text section
- */
- asection *ts = bfd_get_section_by_name (output_bfd, ".text");
+ if (warn)
+ einfo ("%P: warning: cannot find entry symbol %s, defaulting to %V\n",
+ entry_symbol, ts->vma);
- if (ts)
- {
- bfd_set_start_address (output_bfd, ts->vma);
- }
+ bfd_set_start_address (output_bfd, ts->vma);
+ }
+ else
+ {
+ if (warn)
+ einfo ("%P: warning: cannot find entry symbol %s, not setting start address\n",
+ entry_symbol);
}
+ }
}
/* By now we know the target architecture, and we may have an */
/* ldfile_output_machine_name */
static void
-DEFUN_VOID (lang_check)
+lang_check ()
{
lang_statement_union_type *file;
bfd *input_bfd;
file != (lang_statement_union_type *) NULL;
file = file->input_statement.next)
{
- unsigned long ldfile_new_output_machine = 0;
- enum bfd_architecture ldfile_new_output_architecture = bfd_arch_unknown;
-
input_bfd = file->input_statement.the_bfd;
input_machine = bfd_get_mach (input_bfd);
compatible = bfd_arch_get_compatible (input_bfd,
output_bfd);
-
+
if (compatible)
{
ldfile_output_machine = compatible->mach;
else
{
- info ("%P: warning, %s architecture of input file `%B' incompatible with %s output\n",
+ info_msg ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
bfd_printable_name (input_bfd), input_bfd,
bfd_printable_name (output_bfd));
- bfd_set_arch_mach (output_bfd,
- ldfile_new_output_architecture,
- ldfile_new_output_machine);
+ if (! bfd_set_arch_mach (output_bfd,
+ input_architecture,
+ input_machine))
+ einfo ("%P%F:%s: can't set architecture: %E\n",
+ bfd_get_filename (output_bfd));
}
}
*/
static void
-DEFUN_VOID (lang_common)
+lang_common ()
{
ldsym_type *lgs;
size_t power;
}
if (config.sort_common == false || align == power)
{
+ bfd *symbfd;
+
/* Change from a common symbol into a definition of
a symbol */
lgs->sdefs_chain = lgs->scoms_chain;
lgs->scoms_chain = (asymbol **) NULL;
commons_pending--;
+
/* Point to the correct common section */
- com->section =
- ((lang_input_statement_type *)
- (com->the_bfd->usrdata))->common_section;
+ symbfd = bfd_asymbol_bfd (com);
+ if (com->section == &bfd_com_section)
+ com->section =
+ ((lang_input_statement_type *) symbfd->usrdata)
+ ->common_section;
+ else
+ {
+ CONST char *name;
+ asection *newsec;
+
+ name = bfd_get_section_name (symbfd,
+ com->section);
+ newsec = bfd_get_section_by_name (symbfd,
+ name);
+ /* BFD backend must provide this section. */
+ if (newsec == (asection *) NULL)
+ einfo ("%P%F: no output section %s", name);
+ com->section = newsec;
+ }
+
/* Fix the size of the common section */
com->section->_raw_size =
- ALIGN (com->section->_raw_size, align);
+ ALIGN_N (com->section->_raw_size, align);
/* Remember if this is the biggest alignment ever seen */
if (power_of_two > com->section->alignment_power)
com->flags = BSF_EXPORT | BSF_GLOBAL | BSF_OLD_COMMON;
com->value = com->section->_raw_size;
- if (write_map)
+ if (write_map && config.map_file)
{
fprintf (config.map_file, "Allocating common %s: %x at %x %s\n",
lgs->name,
(unsigned) size,
(unsigned) com->value,
- com->the_bfd->filename);
+ bfd_asymbol_bfd(com)->filename);
}
com->section->_raw_size += size;
*/
static void
-DEFUN_VOID (lang_place_orphans)
+lang_place_orphans ()
{
lang_input_statement_type *file;
if (default_common_section ==
(lang_output_section_statement_type *) NULL)
{
- info ("%P: No [COMMON] command, defaulting to .bss\n");
+ info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
default_common_section =
lang_output_section_statement_lookup (".bss");
void
-DEFUN (lang_set_flags, (ptr, flags),
- int *ptr AND
- CONST char *flags)
+lang_set_flags (ptr, flags)
+ int *ptr;
+ CONST char *flags;
{
boolean state = false;
/* ptr->flag_loadable= state;*/
break;
default:
- einfo ("%P%F illegal syntax in flags\n");
+ einfo ("%P%F: invalid syntax in flags\n");
break;
}
flags++;
void
-DEFUN (lang_for_each_file, (func),
- PROTO (void, (*func), (lang_input_statement_type *)))
+lang_for_each_file (func)
+ void (*func) PARAMS ((lang_input_statement_type *));
{
lang_input_statement_type *f;
void
-DEFUN (lang_for_each_input_section, (func),
- PROTO (void, (*func), (bfd * ab, asection * as)))
+lang_for_each_input_section (func)
+ void (*func) PARAMS ((bfd * ab, asection * as));
{
lang_input_statement_type *f;
void
-DEFUN (ldlang_add_file, (entry),
- lang_input_statement_type * entry)
+ldlang_add_file (entry)
+ lang_input_statement_type * entry;
{
lang_statement_append (&file_chain,
}
void
-DEFUN (lang_add_output, (name),
- CONST char *name)
+lang_add_output (name)
+ CONST char *name;
{
lang_output_statement_type *new = new_stat (lang_output_statement,
stat_ptr);
static lang_output_section_statement_type *current_section;
+static int topower(x)
+ int x;
+{
+ unsigned int i = 1;
+ int l;
+ if (x < 0) return -1;
+ for (l = 0; l < 32; l++)
+ {
+ if (i >= x) return l;
+ i<<=1;
+ }
+ return 0;
+}
void
-DEFUN (lang_enter_output_section_statement,
- (output_section_statement_name,
- address_exp,
- flags,
- block_value),
- char *output_section_statement_name AND
- etree_type * address_exp AND
- int flags AND
- bfd_vma block_value)
+lang_enter_output_section_statement (output_section_statement_name,
+ address_exp, flags, block_value,
+ align, subalign, base)
+ char *output_section_statement_name;
+ etree_type * address_exp;
+ int flags;
+ bfd_vma block_value;
+ etree_type *align;
+ etree_type *subalign;
+ etree_type *base;
{
lang_output_section_statement_type *os;
current_section =
- os =
+ os =
lang_output_section_statement_lookup (output_section_statement_name);
if (os->addr_tree ==
(etree_type *) NULL)
- {
- os->addr_tree =
- address_exp;
- }
+ {
+ os->addr_tree =
+ address_exp;
+ }
os->flags = flags;
- os->block_value = block_value;
+ if (flags & SEC_NEVER_LOAD)
+ os->loadable = 0;
+ else
+ os->loadable = 1;
+ os->block_value = block_value ? block_value : 1;
stat_ptr = &os->children;
+ os->subsection_alignment = topower(
+ exp_get_value_int(subalign, -1,
+ "subsection alignment",
+ 0));
+ os->section_alignment = topower(
+ exp_get_value_int(align, -1,
+ "section alignment", 0));
+
+ os->load_base = base;
}
+
void
-DEFUN_VOID (lang_final)
+lang_final ()
{
if (had_output_filename == false)
{
/* Reset the current counters in the regions */
static void
-DEFUN_VOID (reset_memory_regions)
+reset_memory_regions ()
{
lang_memory_region_type *p = lang_memory_region_list;
p != (lang_memory_region_type *) NULL;
p = p->next)
{
+ p->old_length = (bfd_size_type) (p->current - p->origin);
p->current = p->origin;
}
}
+
asymbol *
DEFUN (create_symbol, (name, flags, section),
- CONST char *name AND
- flagword flags AND
- asection * section)
+ CONST char *name AND
+ flagword flags AND
+ asection * section)
{
extern lang_input_statement_type *script_file;
asymbol **def_ptr = (asymbol **) stat_alloc ((bfd_size_type) (sizeof (asymbol **)));
/* Add this definition to script file */
asymbol *def = (asymbol *) bfd_make_empty_symbol (script_file->the_bfd);
-
def->name = buystring (name);
def->udata = 0;
def->flags = flags;
def->section = section;
-
*def_ptr = def;
- Q_enter_global_ref (def_ptr, name);
+ enter_global_ref (def_ptr, name);
return def;
}
void
-DEFUN_VOID (lang_process)
+lang_process ()
{
-
- if (had_script == false)
- {
- parse_line (ldemul_get_script (), 1);
- }
lang_reasonable_defaults ();
current_target = default_target;
current_target = default_target;
lang_for_each_statement (open_input_bfds);
- common_section.userdata = (PTR) & common_section_userdata;
-
-
/* Run through the contours of the script and attatch input sections
to the correct output sections
*/
ldemul_before_allocation ();
- /* Size up the sections */
- lang_size_sections (statement_list.head,
- abs_output_section,
- &(statement_list.head), 0, (bfd_vma) 0, false);
+#if 0
+ had_relax = true;
+ while (had_relax)
+ {
+
+ had_relax = false;
+
+ lang_size_sections (statement_list.head,
+ (lang_output_section_statement_type *) NULL,
+ &(statement_list.head), 0, (bfd_vma) 0, true);
+ /* FIXME. Until the code in relax is fixed so that it only reads in
+ stuff once, we cant iterate since there is no way for the linker to
+ know what has been patched and what hasn't */
+ break;
+ }
+#endif
/* Now run around and relax if we can */
if (command_line.relax)
{
- reset_memory_regions ();
+ /* First time round is a trial run to get the 'worst case' addresses of the
+ objects if there was no relaxing */
+ lang_size_sections (statement_list.head,
+ (lang_output_section_statement_type *) NULL,
+ &(statement_list.head), 0, (bfd_vma) 0, false);
- /* Move the global symbols around */
- lang_relocate_globals ();
- had_relax = true;
- while (had_relax)
- {
- had_relax = false;
+ /* Move the global symbols around so the second pass of relaxing can
+ see them */
+ lang_relocate_globals ();
+
+ reset_memory_regions ();
- lang_size_sections (statement_list.head,
- (lang_output_section_statement_type *) NULL,
- &(statement_list.head), 0, (bfd_vma) 0, true);
- /* FIXME. Until the code in relax is fixed so that it only reads in
- stuff once, we cant iterate since there is no way for the linker to
- know what has been patched and what hasn't */
- break;
+ /* Do all the assignments, now that we know the final restingplaces
+ of all the symbols */
+
+ lang_do_assignments (statement_list.head,
+ abs_output_section,
+ 0, (bfd_vma) 0);
- }
+ /* Perform another relax pass - this time we know where the
+ globals are, so can make better guess */
+ lang_size_sections (statement_list.head,
+ (lang_output_section_statement_type *) NULL,
+ &(statement_list.head), 0, (bfd_vma) 0, true);
}
+ else
+ {
+ /* Size up the sections */
+ lang_size_sections (statement_list.head,
+ abs_output_section,
+ &(statement_list.head), 0, (bfd_vma) 0, false);
+
+ }
+
/* See if anything special should be done now we know how big
everything is */
/* EXPORTED TO YACC */
void
-DEFUN (lang_add_wild, (section_name, filename),
- CONST char *CONST section_name AND
- CONST char *CONST filename)
+lang_add_wild (section_name, filename)
+ CONST char *CONST section_name;
+ CONST char *CONST filename;
{
lang_wild_statement_type *new = new_stat (lang_wild_statement,
stat_ptr);
}
void
-DEFUN (lang_section_start, (name, address),
- CONST char *name AND
- etree_type * address)
+lang_section_start (name, address)
+ CONST char *name;
+ etree_type * address;
{
lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
}
void
-DEFUN (lang_add_entry, (name),
- CONST char *name)
+lang_add_entry (name)
+ CONST char *name;
{
entry_symbol = name;
}
void
-DEFUN (lang_add_target, (name),
- CONST char *name)
+lang_add_target (name)
+ CONST char *name;
{
lang_target_statement_type *new = new_stat (lang_target_statement,
stat_ptr);
}
void
-DEFUN (lang_add_map, (name),
- CONST char *name)
+lang_add_map (name)
+ CONST char *name;
{
while (*name)
{
}
void
-DEFUN (lang_add_fill, (exp),
- int exp)
+lang_add_fill (exp)
+ int exp;
{
lang_fill_statement_type *new = new_stat (lang_fill_statement,
stat_ptr);
}
void
-DEFUN (lang_add_data, (type, exp),
- int type AND
- union etree_union *exp)
+lang_add_data (type, exp)
+ int type;
+ union etree_union *exp;
{
lang_data_statement_type *new = new_stat (lang_data_statement,
}
void
-DEFUN (lang_add_assignment, (exp),
- etree_type * exp)
+lang_add_assignment (exp)
+ etree_type * exp;
{
lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
stat_ptr);
}
void
-DEFUN (lang_add_attribute, (attribute),
- enum statement_enum attribute)
+lang_add_attribute (attribute)
+ enum statement_enum attribute;
{
new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
}
void
-DEFUN (lang_startup, (name),
- CONST char *name)
+lang_startup (name)
+ CONST char *name;
{
if (startup_file != (char *) NULL)
{
- einfo ("%P%FMultiple STARTUP files\n");
+ einfo ("%P%Fmultiple STARTUP files\n");
}
first_file->filename = name;
first_file->local_sym_name = name;
}
void
-DEFUN (lang_float, (maybe),
- boolean maybe)
+lang_float (maybe)
+ boolean maybe;
{
lang_float_flag = maybe;
}
void
-DEFUN (lang_leave_output_section_statement, (fill, memspec),
- bfd_vma fill AND
- CONST char *memspec)
+lang_leave_output_section_statement (fill, memspec)
+ bfd_vma fill;
+ CONST char *memspec;
{
current_section->fill = fill;
current_section->region = lang_memory_region_lookup (memspec);
If the symbol already exists, then do nothing.
*/
void
-DEFUN (lang_abs_symbol_at_beginning_of, (section, name),
- CONST char *section AND
- CONST char *name)
+lang_abs_symbol_at_beginning_of (section, name)
+ CONST char *section;
+ CONST char *name;
{
if (ldsym_undefined (name))
{
If the symbol already exists, then do nothing.
*/
void
-DEFUN (lang_abs_symbol_at_end_of, (section, name),
- CONST char *section AND
- CONST char *name)
+lang_abs_symbol_at_end_of (section, name)
+ CONST char *section;
+ CONST char *name;
{
if (ldsym_undefined (name))
{
}
void
-DEFUN (lang_statement_append, (list, element, field),
- lang_statement_list_type * list AND
- lang_statement_union_type * element AND
- lang_statement_union_type ** field)
+lang_statement_append (list, element, field)
+ lang_statement_list_type * list;
+ lang_statement_union_type * element;
+ lang_statement_union_type ** field;
{
*(list->tail) = element;
list->tail = field;
}
-/* Set the output format type */
+/* Set the output format type. -oformat overrides scripts. */
void
-DEFUN (lang_add_output_format, (format),
- CONST char *format)
+lang_add_output_format (format, from_script)
+ CONST char *format;
+ int from_script;
{
- output_target = format;
+ if (!from_script || output_target == NULL)
+ output_target = format;
}