static asection common_section;
static section_userdata_type common_section_userdata;
static lang_statement_list_type statement_list;
+
/* EXPORTS */
boolean relaxing;
-
+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;
DEFUN(print_size,(value),
size_t value)
{
- printf("%5x", (unsigned)value);
+ fprintf(config.map_file, "%5x", (unsigned)value);
}
static void
DEFUN(print_alignment,(value),
unsigned int value)
{
- printf("2**%1u",value);
+ fprintf(config.map_file, "2**%1u",value);
}
static void
DEFUN(print_fill,(value),
fill_type value)
{
- printf("%04x",(unsigned)value);
+ fprintf(config.map_file, "%04x",(unsigned)value);
}
DEFUN(print_section,(name),
CONST char *CONST name)
{
- printf("%*s", -longest_section_name, name);
+ fprintf(config.map_file, "%*s", -longest_section_name, name);
}
/*----------------------------------------------------------------------
lang_input_statement_type *
DEFUN(lang_add_input_file,(name, file_type, target),
- char *name AND
+ CONST char *name AND
lang_input_file_enum_type file_type AND
- char *target)
+ CONST char *target)
{
/* Look it up or build a new one */
lang_has_input_file = true;
first_file = lang_add_input_file((char *)NULL,
lang_input_file_is_marker_enum,
(char *)NULL);
+abs_output_section = lang_output_section_statement_lookup(BFD_ABS_SECTION_NAME);
+
+abs_output_section->bfd_section = &bfd_abs_section;
+
}
new->origin = 0;
new->length = ~0;
new->current = 0;
+ new->had_full_message = false;
+
return new;
}
}
-
+/*ARGSUSED*/
static void
-DEFUN(print_flags, (outfile, ignore_flags),
- FILE *outfile AND
+DEFUN(print_flags, ( ignore_flags),
int *ignore_flags)
{
- fprintf(outfile,"(");
+ fprintf(config.map_file, "(");
#if 0
if (flags->flag_read) fprintf(outfile,"R");
if (flags->flag_write) fprintf(outfile,"W");
if (flags->flag_executable) fprintf(outfile,"X");
if (flags->flag_loadable) fprintf(outfile,"L");
#endif
- fprintf(outfile,")");
+ fprintf(config.map_file, ")");
}
void
-DEFUN(lang_map,(outfile),
- FILE *outfile)
+DEFUN_VOID(lang_map)
{
lang_memory_region_type *m;
- fprintf(outfile,"**MEMORY CONFIGURATION**\n\n");
+ fprintf(config.map_file,"**MEMORY CONFIGURATION**\n\n");
#ifdef HOST_64_BIT
- fprintf(outfile,"name\t\torigin\t\tlength\t\tattributes\n");
+ fprintf(config.map_file,"name\t\torigin\t\tlength\t\tattributes\n");
#else
- fprintf(outfile,"name\t\torigin length\t\tattributes\n");
+ fprintf(config.map_file,"name\t\torigin length\t\tattributes\n");
#endif
for (m = lang_memory_region_list;
m != (lang_memory_region_type *)NULL;
m = m->next)
{
- fprintf(outfile,"%-16s", m->name);
+ fprintf(config.map_file,"%-16s", m->name);
print_address(m->origin);
print_space();
print_address(m->length);
print_space();
- print_flags(outfile, &m->flags);
- fprintf(outfile,"\n");
+ print_flags( &m->flags);
+ fprintf(config.map_file,"\n");
}
- fprintf(outfile,"\n\n**LINK EDITOR MEMORY MAP**\n\n");
- fprintf(outfile,"output input virtual\n");
- fprintf(outfile,"section section address tsize\n\n");
+ fprintf(config.map_file,"\n\n**LINK EDITOR MEMORY MAP**\n\n");
+ fprintf(config.map_file,"output input virtual\n");
+ fprintf(config.map_file,"section section address tsize\n\n");
print_statements();
DEFUN(init_os,(s),
lang_output_section_statement_type *s)
{
- asection *section = bfd_get_section_by_name(output_bfd, s->name);
- section_userdata_type *new =
- (section_userdata_type *)
- ldmalloc((bfd_size_type)(sizeof(section_userdata_type)));
+/* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
+ section_userdata_type *new =
+ (section_userdata_type *)
+ ldmalloc((bfd_size_type)(sizeof(section_userdata_type)));
s->bfd_section = bfd_get_section_by_name(output_bfd, s->name);
if (s->bfd_section == (asection *)NULL)
- s->bfd_section = bfd_make_section(output_bfd, s->name);
+ 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",
- output_bfd->xvec->name, s->name);
- }
+ 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
lang_reasonable_defaults()
{
+
+
+
#if 0
lang_output_section_statement_lookup(".text");
lang_output_section_statement_lookup(".data");
script_file->the_bfd = bfd_create("script file", 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);
+
+abs_output_section->bfd_section = &bfd_abs_section;
+
}
print_alignment(section->alignment_power);
print_space();
#if 0
- printf("%s flags", output_section_statement->region->name);
+ fprintf(config.map_file, "%s flags", output_section_statement->region->name);
print_flags(stdout, &output_section_statement->flags);
#endif
if (section->flags & SEC_LOAD)
- printf("load ");
+ fprintf(config.map_file, "load ");
if (section->flags & SEC_ALLOC)
- printf("alloc ");
+ fprintf(config.map_file, "alloc ");
if (section->flags & SEC_RELOC)
- printf("reloc ");
+ fprintf(config.map_file, "reloc ");
if (section->flags & SEC_HAS_CONTENTS)
- printf("contents ");
+ fprintf(config.map_file, "contents ");
}
else {
- printf("No attached output section");
+ fprintf(config.map_file, "No attached output section");
}
print_nl();
print_statement(output_section_statement->children.head,
}
else
{
- printf("*undefined*");
+ fprintf(config.map_file, "*undefined*");
}
print_space();
- exp_print_tree(stdout, assignment->exp);
- printf("\n");
+ exp_print_tree(assignment->exp);
+
+ fprintf(config.map_file, "\n");
}
static void
lang_input_statement_type *statm)
{
if (statm->filename != (char *)NULL) {
- printf("LOAD %s\n",statm->filename);
+ fprintf(config.map_file, "LOAD %s\n",statm->filename);
}
}
asymbol *q)
{
print_section("");
- printf(" ");
+ fprintf(config.map_file, " ");
print_section("");
- printf(" ");
+ fprintf(config.map_file, " ");
print_address(outside_symbol_address(q));
- printf(" %s", q->name ? q->name : " ");
+ fprintf(config.map_file, " %s", q->name ? q->name : " ");
print_nl();
}
lang_input_section_type *in)
{
asection *i = in->section;
- int size = i->flags & SEC_HAS_CONTENTS ?
+ int size = i->reloc_done ?
bfd_get_section_size_after_reloc(i) :
bfd_get_section_size_before_reloc(i);
if(size != 0) {
print_section("");
- printf(" ");
+ fprintf(config.map_file, " ");
print_section(i->name);
- printf(" ");
+ fprintf(config.map_file, " ");
if (i->output_section) {
print_address(i->output_section->vma + i->output_offset);
- printf(" ");
+ fprintf(config.map_file, " ");
print_size(size);
- printf(" ");
+ fprintf(config.map_file, " ");
print_alignment(i->alignment_power);
- printf(" ");
+ fprintf(config.map_file, " ");
if (in->ifile) {
bfd *abfd = in->ifile->the_bfd;
if (in->ifile->just_syms_flag == true) {
- printf("symbols only ");
+ fprintf(config.map_file, "symbols only ");
}
- printf(" %s ",abfd->xvec->name);
+ fprintf(config.map_file, " %s ",abfd->xvec->name);
if(abfd->my_archive != (bfd *)NULL) {
- printf("[%s]%s", abfd->my_archive->filename,
+ fprintf(config.map_file, "[%s]%s", abfd->my_archive->filename,
abfd->filename);
}
else {
- printf("%s", abfd->filename);
+ fprintf(config.map_file, "%s", abfd->filename);
}
- printf("(overhead %d bytes)", (int)bfd_alloc_size(abfd));
+ fprintf(config.map_file, "(overhead %d bytes)", (int)bfd_alloc_size(abfd));
print_nl();
/* Find all the symbols in this file defined in this section */
print_dot = outside_section_address(i) + size;
}
else {
- printf("No output section allocated\n");
+ fprintf(config.map_file, "No output section allocated\n");
}
}
}
DEFUN(print_fill_statement,(fill),
lang_fill_statement_type *fill)
{
- printf("FILL mask ");
+ fprintf(config.map_file, "FILL mask ");
print_fill( fill->fill);
}
print_space();
/* ASSERT(print_dot == data->output_vma);*/
- print_address(data->output_vma);
+ print_address(data->output_vma + data->output_section->vma);
print_space();
print_address(data->value);
print_space();
switch (data->type) {
case BYTE :
- printf("BYTE ");
+ fprintf(config.map_file, "BYTE ");
print_dot += BYTE_SIZE;
break;
case SHORT:
- printf("SHORT ");
+ fprintf(config.map_file, "SHORT ");
print_dot += SHORT_SIZE;
break;
case LONG:
- printf("LONG ");
+ fprintf(config.map_file, "LONG ");
print_dot += LONG_SIZE;
break;
}
- exp_print_tree(stdout, data->exp);
+ exp_print_tree(data->exp);
- printf("\n");
+ fprintf(config.map_file, "\n");
}
print_space();
print_fill(s->fill);
print_nl();
+
+ print_dot = s->output_offset + s->output_section->vma + s->size;
+
}
static void
lang_wild_statement_type *w AND
lang_output_section_statement_type *os)
{
- printf(" from ");
+ fprintf(config.map_file, " from ");
if (w->filename != (char *)NULL) {
- printf("%s",w->filename);
+ fprintf(config.map_file, "%s",w->filename);
}
else {
- printf("*");
+ fprintf(config.map_file, "*");
}
if (w->section_name != (char *)NULL) {
- printf("(%s)",w->section_name);
+ fprintf(config.map_file, "(%s)",w->section_name);
}
else {
- printf("(*)");
+ fprintf(config.map_file, "(*)");
}
print_nl();
print_statement(w->children.head, os);
switch (s->header.type)
{
case lang_constructors_statement_enum:
- printf("constructors:\n");
+ fprintf(config.map_file, "constructors:\n");
print_statement(constructor_list.head, os);
break;
case lang_wild_statement_enum:
print_wild_statement(&s->wild_statement, os);
break;
default:
- printf("Fail with %d\n",s->header.type);
+ fprintf(config.map_file, "Fail with %d\n",s->header.type);
FAIL();
break;
case lang_address_statement_enum:
- printf("address\n");
+ fprintf(config.map_file, "address\n");
break;
break;
case lang_object_symbols_statement_enum:
- printf("object symbols\n");
+ fprintf(config.map_file, "object symbols\n");
break;
case lang_fill_statement_enum:
print_fill_statement(&s->fill_statement);
os);
break;
case lang_target_statement_enum:
- printf("TARGET(%s)\n", s->target_statement.target);
+ fprintf(config.map_file, "TARGET(%s)\n", s->target_statement.target);
break;
case lang_output_statement_enum:
- printf("OUTPUT(%s %s)\n",
+ fprintf(config.map_file, "OUTPUT(%s %s)\n",
s->output_statement.name,
output_target);
break;
DEFUN_VOID(print_statements)
{
print_statement(statement_list.head,
- (lang_output_section_statement_type *)NULL);
+ abs_output_section);
+
}
static bfd_vma
return dot ;
}
-#if 0
-/* Work out the size of the output sections
- from the sizes of the input sections */
-static bfd_vma
-DEFUN(lang_size_sections,(s, output_section_statement, prev, fill,
- dot),
- 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)
-
-{
- /* Size up the sections from their constituent parts */
- for (; s != (lang_statement_union_type *)NULL ; s = s->next)
- {
- switch (s->header.type) {
-
-
- case lang_output_section_statement_enum:
- {
- bfd_vma after;
- lang_output_section_statement_type *os =
- &(s->output_section_statement);
- /* The start of a section */
-
- 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,
- (lang_output_section_statement_type *)NULL,
- 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;
- os->bfd_section->output_offset = 0;
-
- (void) lang_size_sections(os->children.head, os, &os->children.head,
- os->fill, dot);
- /* Ignore the size of the input sections, use the vma and size to */
- /* align against */
-
-
- after = ALIGN(os->bfd_section->vma +
- os->bfd_section->size,
- os->block_value) ;
-
-
- os->bfd_section->size = after - os->bfd_section->vma;
- dot = os->bfd_section->vma + os->bfd_section->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;
- }
- }
-
- break;
- case lang_constructors_statement_enum:
- dot = lang_size_sections(constructor_list.head,
- output_section_statement,
- &s->wild_statement.children.head,
- fill,
- dot);
- 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->size += size;
- }
- break;
-
- case lang_wild_statement_enum:
-
- dot = lang_size_sections(s->wild_statement.children.head,
- output_section_statement,
- &s->wild_statement.children.head,
-
- fill, dot);
-
- 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:
- 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:
- 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)
- /* We've been moved ! so insert a pad */
- {
- lang_statement_union_type *new =
- (lang_statement_union_type *)
- ldmalloc((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->size +=
- new->padding_statement.size;
- dot = newdot;
- }
- }
- break;
- case lang_padding_statement_enum:
- FAIL();
- break;
- default:
- FAIL();
- break;
- case lang_address_statement_enum:
- break;
- }
- prev = &s->header.next;
- }
- return dot;
-}
-#else
/* Sizing happens in two passes, first pass we allocate worst case
stuff. The second pass (if relaxing), we use what we learnt to
change the size of some relocs from worst case to better
{
/* Size up the sections from their constituent parts */
for (; s != (lang_statement_union_type *)NULL ; s = s->next)
- {
- switch (s->header.type) {
-
- case lang_output_section_statement_enum:
- {
- bfd_vma after;
- lang_output_section_statement_type *os =
- &(s->output_section_statement);
- /* The start of a section */
+ {
+ switch (s->header.type) {
- 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,
- (lang_output_section_statement_type *)NULL,
- 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;
+ 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*");
}
- /* The section starts here */
- /* First, align to what the section needs */
+ 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;
- 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 */
+ dot = align_power(dot, os->bfd_section->alignment_power);
+ os->bfd_section->vma = dot;
+ }
+
+
+ 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) ;
+ 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;
- }
- }
+ os->bfd_section->_raw_size = after - os->bfd_section->vma;
+ dot = os->bfd_section->vma + os->bfd_section->_raw_size;
+ os->processed = true;
- 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:
+ /* 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)
{
- 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;
+ 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;
- }
- 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;
+
+ 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:
- dot = lang_size_sections(s->wild_statement.children.head,
+ dot = lang_size_sections(s->wild_statement.children.head,
output_section_statement,
&s->wild_statement.children.head,
fill, dot, relax);
- break;
+ 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;
+ 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;
-had_relax |= relax_section(prev);
- relaxing = false;
+ had_relax |= relax_section(prev);
+ relaxing = false;
-}
+ }
- dot = size_input_section(prev,
+ 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:
- 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)
- /* We've been moved ! so insert a pad */
- {
- lang_statement_union_type *new =
- (lang_statement_union_type *)
- ldmalloc((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;
+ case lang_input_statement_enum:
+ break;
+ case lang_fill_statement_enum:
+ 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 *)
+ ldmalloc((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;
}
-#endif
+
static bfd_vma
DEFUN(lang_do_assignments,(s, output_section_statement, fill, dot),
{
etree_value_type value ;
value = exp_fold_tree(s->data_statement.exp,
- 0, lang_final_phase_enum, dot, &dot);
+ abs_output_section,
+ lang_final_phase_enum, dot, &dot);
s->data_statement.value = value.value;
if (value.valid == false) einfo("%F%P: Invalid data statement\n");
}
if (write_map)
{
- printf ("Allocating common %s: %x at %x %s\n",
+ fprintf (config.map_file, "Allocating common %s: %x at %x %s\n",
lgs->name,
(unsigned) size,
(unsigned) com->value,
void
DEFUN_VOID(lang_process)
{
+
if (had_script == false) {
- parse_line(ldemul_get_script());
+ parse_line(ldemul_get_script(),1);
}
lang_reasonable_defaults();
current_target = default_target;
/* Size up the sections */
lang_size_sections(statement_list.head,
- (lang_output_section_statement_type *)NULL,
+ abs_output_section,
&(statement_list.head), 0, (bfd_vma)0, false);
- /* Move the global symbols around */
- lang_relocate_globals();
-
/* Now run around and relax if we can */
if (command_line.relax)
{
reset_memory_regions();
+
+ /* Move the global symbols around */
+ lang_relocate_globals();
had_relax = true;
while (had_relax)
of all the symbols */
lang_do_assignments(statement_list.head,
- (lang_output_section_statement_type *)NULL,
+ abs_output_section,
0, (bfd_vma)0);
+ /* Move the global symbols around */
+ lang_relocate_globals();
+
/* Make sure that we're not mixing architectures */
lang_check();
projects / binutils.git / blobdiff