1 /* Copyright (C) 1991 Free Software Foundation, Inc.
3 This file is part of GLD, the Gnu Linker.
5 GLD is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 1, or (at your option)
10 GLD is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GLD; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "ldgram.tab.h"
39 PROTO(static void, print_statements,(void));
40 PROTO(static void, print_statement,(lang_statement_union_type *,
41 lang_output_section_statement_type *));
45 static CONST char *startup_file;
46 static lang_statement_list_type input_file_chain;
47 static boolean placed_commons = false;
48 static lang_output_section_statement_type *default_common_section;
49 static boolean map_option_f;
50 static bfd_vma print_dot;
51 static lang_input_statement_type *first_file;
52 static lang_statement_list_type lang_output_section_statement;
53 static CONST char *current_target;
54 static CONST char *output_target;
55 static size_t longest_section_name = 8;
56 static asection common_section;
57 static section_userdata_type common_section_userdata;
58 static lang_statement_list_type statement_list;
61 lang_statement_list_type *stat_ptr = &statement_list;
62 lang_input_statement_type *script_file = 0;
63 boolean option_longmap = false;
64 lang_statement_list_type file_chain = {0};
65 CONST char *entry_symbol = 0;
66 size_t largest_section = 0;
67 boolean lang_has_input_file = false;
68 lang_output_section_statement_type *create_object_symbols = 0;
69 boolean had_output_filename = false;
70 boolean lang_float_flag = false;
72 extern char *default_target;
74 extern unsigned int undefined_global_sym_count;
75 extern char *current_file;
76 extern bfd *output_bfd;
77 extern enum bfd_architecture ldfile_output_architecture;
78 extern unsigned long ldfile_output_machine;
79 extern char *ldfile_output_machine_name;
80 extern ldsym_type *symbol_head;
81 extern unsigned int commons_pending;
82 extern args_type command_line;
83 extern ld_config_type config;
84 extern boolean had_script;
85 extern boolean write_map;
91 #define cat(a,b) a/**/b
94 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
96 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
98 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
102 /*----------------------------------------------------------------------
103 lang_for_each_statement walks the parse tree and calls the provided
104 function for each node
108 DEFUN(lang_for_each_statement_worker,(func, s),
110 lang_statement_union_type *s)
112 for (; s != (lang_statement_union_type *)NULL ; s = s->next)
116 switch (s->header.type) {
117 case lang_output_section_statement_enum:
118 lang_for_each_statement_worker
120 s->output_section_statement.children.head);
122 case lang_wild_statement_enum:
123 lang_for_each_statement_worker
125 s->wild_statement.children.head);
127 case lang_data_statement_enum:
128 case lang_object_symbols_statement_enum:
129 case lang_output_statement_enum:
130 case lang_target_statement_enum:
131 case lang_input_section_enum:
132 case lang_input_statement_enum:
133 case lang_fill_statement_enum:
134 case lang_assignment_statement_enum:
135 case lang_padding_statement_enum:
136 case lang_address_statement_enum:
146 DEFUN(lang_for_each_statement,(func),
149 lang_for_each_statement_worker(func,
150 statement_list.head);
152 /*----------------------------------------------------------------------*/
154 DEFUN(lang_list_init,(list),
155 lang_statement_list_type *list)
157 list->head = (lang_statement_union_type *)NULL;
158 list->tail = &list->head;
161 /*----------------------------------------------------------------------
162 Functions to print the link map
166 DEFUN(print_section,(name),
167 CONST char *CONST name)
169 printf("%*s", -longest_section_name, name);
172 DEFUN_VOID(print_space)
182 DEFUN(print_address,(value),
185 printf("%8lx", value);
188 DEFUN(print_size,(value),
191 printf("%5x", (unsigned)value);
194 DEFUN(print_alignment,(value),
197 printf("2**%2u",value);
201 DEFUN(print_fill,(value),
204 printf("%04x",(unsigned)value);
207 /*----------------------------------------------------------------------
209 build a new statement node for the parse tree
214 lang_statement_union_type*
215 DEFUN(new_statement,(type, size, list),
216 enum statement_enum type AND
218 lang_statement_list_type *list)
220 lang_statement_union_type *new = (lang_statement_union_type *)
222 new->header.type = type;
223 new->header.next = (lang_statement_union_type *)NULL;
224 lang_statement_append(list, new, &new->header.next);
229 Build a new input file node for the language. There are several ways
230 in which we treat an input file, eg, we only look at symbols, or
231 prefix it with a -l etc.
233 We can be supplied with requests for input files more than once;
234 they may, for example be split over serveral lines like foo.o(.text)
235 foo.o(.data) etc, so when asked for a file we check that we havn't
236 got it already so we don't duplicate the bfd.
239 static lang_input_statement_type *
240 DEFUN(new_afile, (name, file_type, target),
241 CONST char *CONST name AND
242 CONST lang_input_file_enum_type file_type AND
243 CONST char *CONST target)
245 lang_input_statement_type *p = new_stat(lang_input_statement,
247 lang_has_input_file = true;
250 case lang_input_file_is_symbols_only_enum:
252 p->is_archive =false;
254 p->local_sym_name= name;
255 p->just_syms_flag = true;
256 p->search_dirs_flag = false;
258 case lang_input_file_is_fake_enum:
260 p->is_archive =false;
262 p->local_sym_name= name;
263 p->just_syms_flag = false;
264 p->search_dirs_flag =false;
266 case lang_input_file_is_l_enum:
267 p->is_archive = true;
270 p->local_sym_name = concat("-l",name,"");
271 p->just_syms_flag = false;
272 p->search_dirs_flag = true;
274 case lang_input_file_is_search_file_enum:
275 case lang_input_file_is_marker_enum:
277 p->is_archive =false;
279 p->local_sym_name= name;
280 p->just_syms_flag = false;
281 p->search_dirs_flag =true;
283 case lang_input_file_is_file_enum:
285 p->is_archive =false;
287 p->local_sym_name= name;
288 p->just_syms_flag = false;
289 p->search_dirs_flag =false;
294 p->asymbols = (asymbol **)NULL;
295 p->superfile = (lang_input_statement_type *)NULL;
296 p->next_real_file = (lang_statement_union_type*)NULL;
297 p->next = (lang_statement_union_type*)NULL;
299 p->common_output_section = (asection *)NULL;
300 lang_statement_append(&input_file_chain,
301 (lang_statement_union_type *)p,
308 lang_input_statement_type *
309 DEFUN(lang_add_input_file,(name, file_type, target),
311 lang_input_file_enum_type file_type AND
314 /* Look it up or build a new one */
315 lang_has_input_file = true;
317 lang_input_statement_type *p;
319 for (p = (lang_input_statement_type *)input_file_chain.head;
320 p != (lang_input_statement_type *)NULL;
321 p = (lang_input_statement_type *)(p->next_real_file))
323 /* Sometimes we have incomplete entries in here */
324 if (p->filename != (char *)NULL) {
325 if(strcmp(name,p->filename) == 0) return p;
330 return new_afile(name, file_type, target);
334 /* Build enough state so that the parser can build its tree */
336 DEFUN_VOID(lang_init)
339 stat_ptr= &statement_list;
340 lang_list_init(stat_ptr);
342 lang_list_init(&input_file_chain);
343 lang_list_init(&lang_output_section_statement);
344 lang_list_init(&file_chain);
345 first_file = lang_add_input_file((char *)NULL,
346 lang_input_file_is_marker_enum,
351 /*----------------------------------------------------------------------
352 A region is an area of memory declared with the
353 MEMORY { name:org=exp, len=exp ... }
356 We maintain a list of all the regions here
358 If no regions are specified in the script, then the default is used
359 which is created when looked up to be the entire data space
362 static lang_memory_region_type *lang_memory_region_list;
363 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
365 lang_memory_region_type *
366 DEFUN(lang_memory_region_lookup,(name),
367 CONST char *CONST name)
370 lang_memory_region_type *p = lang_memory_region_list;
371 for (p = lang_memory_region_list;
372 p != ( lang_memory_region_type *)NULL;
374 if (strcmp(p->name, name) == 0) {
378 if (strcmp(name,"*default*")==0) {
379 /* This is the default region, dig out first one on the list */
380 if (lang_memory_region_list != (lang_memory_region_type*)NULL){
381 return lang_memory_region_list;
385 lang_memory_region_type *new =
386 (lang_memory_region_type *)ldmalloc(sizeof(lang_memory_region_type));
387 new->name = buystring(name);
388 new->next = (lang_memory_region_type *)NULL;
390 *lang_memory_region_list_tail = new;
391 lang_memory_region_list_tail = &new->next;
400 lang_output_section_statement_type *
401 DEFUN(lang_output_section_find,(name),
402 CONST char * CONST name)
404 lang_statement_union_type *u;
405 lang_output_section_statement_type *lookup;
407 for (u = lang_output_section_statement.head;
408 u != (lang_statement_union_type *)NULL;
411 lookup = &u->output_section_statement;
412 if (strcmp(name, lookup->name)==0) {
416 return (lang_output_section_statement_type *)NULL;
419 lang_output_section_statement_type *
420 DEFUN(lang_output_section_statement_lookup,(name),
421 CONST char * CONST name)
423 lang_output_section_statement_type *lookup;
424 lookup =lang_output_section_find(name);
425 if (lookup == (lang_output_section_statement_type *)NULL) {
427 lookup =(lang_output_section_statement_type *)
428 new_stat(lang_output_section_statement, stat_ptr);
429 lookup->region = (lang_memory_region_type *)NULL;
431 lookup->block_value = 1;
434 lookup->next = (lang_statement_union_type*)NULL;
435 lookup->bfd_section = (asection *)NULL;
436 lookup->processed = false;
437 lookup->addr_tree = (etree_type *)NULL;
438 lang_list_init(&lookup->children);
440 lang_statement_append(&lang_output_section_statement,
441 (lang_statement_union_type *)lookup,
452 DEFUN(print_flags, (outfile, ignore_flags),
454 lang_section_flags_type *ignore_flags)
456 fprintf(outfile,"(");
458 if (flags->flag_read) fprintf(outfile,"R");
459 if (flags->flag_write) fprintf(outfile,"W");
460 if (flags->flag_executable) fprintf(outfile,"X");
461 if (flags->flag_loadable) fprintf(outfile,"L");
463 fprintf(outfile,")");
467 DEFUN(lang_map,(outfile),
470 lang_memory_region_type *m;
471 fprintf(outfile,"**MEMORY CONFIGURATION**\n\n");
473 fprintf(outfile,"name\t\torigin\t\tlength\t\tattributes\n");
474 for (m = lang_memory_region_list;
475 m != (lang_memory_region_type *)NULL;
478 fprintf(outfile,"%-16s", m->name);
480 fprintf(outfile,"%08lx\t%08lx\t", m->origin, m->length);
481 print_flags(outfile, &m->flags);
482 fprintf(outfile,"\n");
484 fprintf(outfile,"\n\n**LINK EDITOR MEMORY MAP**\n\n");
485 fprintf(outfile,"output\t\tinput\t\tvirtual\n");
486 fprintf(outfile,"section\t\tsection\t\taddress\tsize\n\n");
497 lang_output_section_statement_type *s)
499 section_userdata_type *new =
500 (section_userdata_type *)
501 ldmalloc(sizeof(section_userdata_type));
503 s->bfd_section = bfd_make_section(output_bfd, s->name);
504 s->bfd_section->output_section = s->bfd_section;
505 s->bfd_section->flags = SEC_NO_FLAGS;
506 /* We initialize an output sections output offset to minus its own */
507 /* vma to allow us to output a section through itself */
508 s->bfd_section->output_offset = 0;
509 get_userdata( s->bfd_section) = new;
512 /***********************************************************************
515 These expand statements like *(.text) and foo.o to a list of
516 explicit actions, like foo.o(.text), bar.o(.text) and
519 The toplevel routine, wild, takes a statement, section, file and
520 target. If either the section or file is null it is taken to be the
521 wildcard. Seperate lang_input_section statements are created for
522 each part of the expanstion, and placed after the statement provided.
527 DEFUN(wild_doit,(ptr, section, output, file),
528 lang_statement_list_type *ptr AND
529 asection *section AND
530 lang_output_section_statement_type *output AND
531 lang_input_statement_type *file)
533 if(output->bfd_section == (asection *)NULL)
538 if (section != (asection *)NULL
539 && section->output_section == (asection *)NULL) {
540 /* Add a section reference to the list */
541 lang_input_section_type *new = new_stat(lang_input_section, ptr);
543 new->section = section;
545 section->output_section = output->bfd_section;
546 section->output_section->flags |= section->flags;
547 if (section->alignment_power > output->bfd_section->alignment_power) {
548 output->bfd_section->alignment_power = section->alignment_power;
554 DEFUN(our_bfd_get_section_by_name,(abfd, section),
558 return bfd_get_section_by_name(abfd, section);
562 DEFUN(wild_section,(ptr, section, file , output),
563 lang_wild_statement_type *ptr AND
564 CONST char *section AND
565 lang_input_statement_type *file AND
566 lang_output_section_statement_type *output)
569 if (file->just_syms_flag == false) {
570 if (section == (char *)NULL) {
571 /* Do the creation to all sections in the file */
572 for (s = file->the_bfd->sections; s != (asection *)NULL; s=s->next) {
573 wild_doit(&ptr->children, s, output, file);
577 /* Do the creation to the named section only */
578 wild_doit(&ptr->children,
579 our_bfd_get_section_by_name(file->the_bfd, section),
586 /* passed a file name (which must have been seen already and added to
587 the statement tree. We will see if it has been opened already and
588 had its symbols read. If not then we'll read it.
590 Archives are pecuilar here. We may open them once, but if they do
591 not define anything we need at the time, they won't have all their
592 symbols read. If we need them later, we'll have to redo it.
595 lang_input_statement_type *
596 DEFUN(lookup_name,(name),
597 CONST char * CONST name)
599 lang_input_statement_type *search;
600 for(search = (lang_input_statement_type *)input_file_chain.head;
601 search != (lang_input_statement_type *)NULL;
602 search = (lang_input_statement_type *)search->next_real_file)
604 if (search->filename == (char *)NULL && name == (char *)NULL) {
607 if (search->filename != (char *)NULL && name != (char *)NULL) {
608 if (strcmp(search->filename, name) == 0) {
609 ldmain_open_file_read_symbol(search);
615 /* There isn't an afile entry for this file yet, this must be
616 because the name has only appeared inside a load script and not
617 on the command line */
618 search = new_afile(name, lang_input_file_is_file_enum, default_target);
619 ldmain_open_file_read_symbol(search);
626 DEFUN(wild,(s, section, file, target, output),
627 lang_wild_statement_type *s AND
628 CONST char *CONST section AND
629 CONST char *CONST file AND
630 CONST char *CONST target AND
631 lang_output_section_statement_type *output)
633 lang_input_statement_type *f;
634 if (file == (char *)NULL) {
635 /* Perform the iteration over all files in the list */
636 for (f = (lang_input_statement_type *)file_chain.head;
637 f != (lang_input_statement_type *)NULL;
638 f = (lang_input_statement_type *)f->next) {
639 wild_section(s, section, f, output);
643 /* Perform the iteration over a single file */
644 wild_section( s, section, lookup_name(file), output);
646 if (section != (char *)NULL
647 && strcmp(section,"COMMON") == 0
648 && default_common_section == (lang_output_section_statement_type*)NULL)
650 /* Remember the section that common is going to incase we later
651 get something which doesn't know where to put it */
652 default_common_section = output;
657 read in all the files
660 DEFUN(open_output,(name),
661 CONST char *CONST name)
663 extern CONST char *output_filename;
665 if (output_target == (char *)NULL) {
666 if (current_target != (char *)NULL)
667 output_target = current_target;
669 output_target = default_target;
671 output = bfd_openw(name, output_target);
672 output_filename = name;
674 if (output == (bfd *)NULL)
676 if (bfd_error == invalid_target) {
677 info("%P%F target %s not found\n", output_target);
679 info("%P%F problem opening output file %s, %E", name);
682 output->flags |= D_PAGED;
683 bfd_set_format(output, bfd_object);
691 DEFUN(ldlang_open_output,(statement),
692 lang_statement_union_type *statement)
694 switch (statement->header.type)
696 case lang_output_statement_enum:
697 output_bfd = open_output(statement->output_statement.name);
698 ldemul_set_output_arch();
701 case lang_target_statement_enum:
702 current_target = statement->target_statement.target;
710 DEFUN(open_input_bfds,(statement),
711 lang_statement_union_type *statement)
713 switch (statement->header.type)
715 case lang_target_statement_enum:
716 current_target = statement->target_statement.target;
718 case lang_wild_statement_enum:
719 /* Maybe we should load the file's symbols */
720 if (statement->wild_statement.filename)
722 (void) lookup_name(statement->wild_statement.filename);
725 case lang_input_statement_enum:
726 if (statement->input_statement.real == true)
728 statement->input_statement.target = current_target;
729 lookup_name(statement->input_statement.filename);
736 /* If there are [COMMONS] statements, put a wild one into the bss section */
739 lang_reasonable_defaults()
742 lang_output_section_statement_lookup(".text");
743 lang_output_section_statement_lookup(".data");
745 default_common_section =
746 lang_output_section_statement_lookup(".bss");
749 if (placed_commons == false) {
750 lang_wild_statement_type *new =
751 new_stat(lang_wild_statement,
752 &default_common_section->children);
753 new->section_name = "COMMON";
754 new->filename = (char *)NULL;
755 lang_list_init(&new->children);
762 Add the supplied name to the symbol table as an undefined reference.
763 Remove items from the chain as we open input bfds
765 typedef struct ldlang_undef_chain_list_struct {
766 struct ldlang_undef_chain_list_struct *next;
768 } ldlang_undef_chain_list_type;
770 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
773 DEFUN(ldlang_add_undef,(name),
774 CONST char *CONST name)
776 ldlang_undef_chain_list_type *new =
777 (ldlang_undef_chain_list_type
778 *)ldmalloc(sizeof(ldlang_undef_chain_list_type));
780 new->next = ldlang_undef_chain_list_head;
781 ldlang_undef_chain_list_head = new;
783 new->name = buystring(name);
785 /* Run through the list of undefineds created above and place them
786 into the linker hash table as undefined symbols belonging to the
790 DEFUN_VOID(lang_place_undefineds)
792 ldlang_undef_chain_list_type *ptr = ldlang_undef_chain_list_head;
793 while (ptr != (ldlang_undef_chain_list_type*)NULL) {
794 ldsym_type *sy = ldsym_get(ptr->name);
796 asymbol **def_ptr = (asymbol **)ldmalloc(sizeof(asymbol **));
797 def = (asymbol *)bfd_make_empty_symbol(script_file->the_bfd);
799 def->name = ptr->name;
800 def->flags = BSF_UNDEFINED;
801 def->section = (asection *)NULL;
802 Q_enter_global_ref(def_ptr);
809 /* Copy important data from out internal form to the bfd way. Also
810 create a section for the dummy file
814 DEFUN_VOID(lang_create_output_section_statements)
816 lang_statement_union_type*os;
817 for (os = lang_output_section_statement.head;
818 os != (lang_statement_union_type*)NULL;
819 os = os->output_section_statement.next) {
820 lang_output_section_statement_type *s =
821 &os->output_section_statement;
828 DEFUN_VOID(lang_init_script_file)
830 script_file = lang_add_input_file("script file",
831 lang_input_file_is_fake_enum,
833 script_file->the_bfd = bfd_create("script file", output_bfd);
834 script_file->symbol_count = 0;
835 script_file->the_bfd->sections = output_bfd->sections;
841 /* Open input files and attatch to output sections */
843 DEFUN(map_input_to_output_sections,(s, target, output_section_statement),
844 lang_statement_union_type *s AND
845 CONST char *target AND
846 lang_output_section_statement_type *output_section_statement)
848 for (; s != (lang_statement_union_type *)NULL ; s = s->next)
850 switch (s->header.type) {
851 case lang_wild_statement_enum:
852 wild(&s->wild_statement, s->wild_statement.section_name,
853 s->wild_statement.filename, target,
854 output_section_statement);
858 case lang_output_section_statement_enum:
859 map_input_to_output_sections(s->output_section_statement.children.head,
861 &s->output_section_statement);
863 case lang_output_statement_enum:
865 case lang_target_statement_enum:
866 target = s->target_statement.target;
868 case lang_fill_statement_enum:
869 case lang_input_section_enum:
870 case lang_object_symbols_statement_enum:
871 case lang_data_statement_enum:
872 case lang_assignment_statement_enum:
873 case lang_padding_statement_enum:
875 case lang_afile_asection_pair_statement_enum:
878 case lang_address_statement_enum:
879 /* Mark the specified section with the supplied address */
881 lang_output_section_statement_type *os =
882 lang_output_section_statement_lookup
883 (s->address_statement.section_name);
884 os->addr_tree = s->address_statement.address;
887 case lang_input_statement_enum:
888 /* A standard input statement, has no wildcards */
889 /* ldmain_open_file_read_symbol(&s->input_statement);*/
900 DEFUN(print_output_section_statement,(output_section_statement),
901 lang_output_section_statement_type *output_section_statement)
903 asection *section = output_section_statement->bfd_section;
905 print_section(output_section_statement->name);
908 print_dot = section->vma;
912 print_address(section->vma);
914 print_size(section->size);
916 print_alignment(section->alignment_power);
919 printf("%s flags", output_section_statement->region->name);
920 print_flags(stdout, &output_section_statement->flags);
925 printf("No attached output section");
928 print_statement(output_section_statement->children.head,
929 output_section_statement);
934 DEFUN(print_assignment,(assignment, output_section),
935 lang_assignment_statement_type *assignment AND
936 lang_output_section_statement_type *output_section)
938 etree_value_type result;
943 print_address(print_dot);
945 result = exp_fold_tree(assignment->exp->assign.src,
947 lang_final_phase_enum,
952 print_address(result.value);
956 printf("*undefined*");
959 exp_print_tree(stdout, assignment->exp);
964 DEFUN(print_input_statement,(statm),
965 lang_input_statement_type *statm)
967 if (statm->filename != (char *)NULL) {
968 printf("LOAD %s\n",statm->filename);
973 DEFUN(print_symbol,(q),
980 print_address(outside_symbol_address(q));
981 printf(" %s", q->name ? q->name : " ");
986 DEFUN(print_input_section,(in),
987 lang_input_section_type *in)
989 asection *i = in->section;
994 print_section(i->name);
996 if (i->output_section) {
997 print_address(i->output_section->vma + i->output_offset);
1001 print_alignment(i->alignment_power);
1005 bfd *abfd = in->ifile->the_bfd;
1006 if (in->ifile->just_syms_flag == true) {
1007 printf("symbols only ");
1010 printf(" %s ",abfd->xvec->name);
1011 if(abfd->my_archive != (bfd *)NULL) {
1012 printf("[%s]%s", abfd->my_archive->filename,
1016 printf("%s", abfd->filename);
1020 /* Find all the symbols in this file defined in this section */
1023 for (p = in->ifile->asymbols; *p; p++) {
1026 if (bfd_get_section(q) == i && q->flags & BSF_GLOBAL) {
1037 print_dot = outside_section_address(i) + i->size;
1040 printf("No output section allocated\n");
1046 DEFUN(print_fill_statement,(fill),
1047 lang_fill_statement_type *fill)
1049 printf("FILL mask ");
1050 print_fill( fill->fill);
1054 DEFUN(print_data_statement,(data),
1055 lang_data_statement_type *data)
1057 /* bfd_vma value; */
1062 ASSERT(print_dot == data->output_vma);
1064 print_address(data->output_vma);
1066 print_address(data->value);
1068 switch (data->type) {
1071 print_dot += BYTE_SIZE;
1075 print_dot += SHORT_SIZE;
1079 print_dot += LONG_SIZE;
1083 exp_print_tree(stdout, data->exp);
1090 DEFUN(print_padding_statement,(s),
1091 lang_padding_statement_type *s)
1095 print_section("*fill*");
1097 print_address(s->output_offset + s->output_section->vma);
1099 print_size(s->size);
1101 print_fill(s->fill);
1106 DEFUN(print_wild_statement,(w,os),
1107 lang_wild_statement_type *w AND
1108 lang_output_section_statement_type *os)
1110 if (w->filename != (char *)NULL) {
1111 printf("%s",w->filename);
1116 if (w->section_name != (char *)NULL) {
1117 printf("(%s)",w->section_name);
1123 print_statement(w->children.head, os);
1127 DEFUN(print_statement,(s, os),
1128 lang_statement_union_type *s AND
1129 lang_output_section_statement_type *os)
1132 switch (s->header.type) {
1133 case lang_wild_statement_enum:
1134 print_wild_statement(&s->wild_statement, os);
1137 printf("Fail with %d\n",s->header.type);
1140 case lang_address_statement_enum:
1141 printf("address\n");
1144 case lang_object_symbols_statement_enum:
1145 printf("object symbols\n");
1147 case lang_fill_statement_enum:
1148 print_fill_statement(&s->fill_statement);
1150 case lang_data_statement_enum:
1151 print_data_statement(&s->data_statement);
1153 case lang_input_section_enum:
1154 print_input_section(&s->input_section);
1156 case lang_padding_statement_enum:
1157 print_padding_statement(&s->padding_statement);
1159 case lang_output_section_statement_enum:
1160 print_output_section_statement(&s->output_section_statement);
1162 case lang_assignment_statement_enum:
1163 print_assignment(&s->assignment_statement,
1168 case lang_target_statement_enum:
1169 printf("TARGET(%s)\n", s->target_statement.target);
1171 case lang_output_statement_enum:
1172 printf("OUTPUT(%s %s)\n",
1173 s->output_statement.name,
1176 case lang_input_statement_enum:
1177 print_input_statement(&s->input_statement);
1179 case lang_afile_asection_pair_statement_enum:
1189 DEFUN_VOID(print_statements)
1191 print_statement(statement_list.head,
1192 (lang_output_section_statement_type *)NULL);
1196 DEFUN(insert_pad,(this_ptr, fill, power, output_section_statement, dot),
1197 lang_statement_union_type **this_ptr AND
1199 unsigned int power AND
1200 asection * output_section_statement AND
1203 /* Align this section first to the
1204 input sections requirement, then
1205 to the output section's requirement.
1206 If this alignment is > than any seen before,
1207 then record it too. Perform the alignment by
1208 inserting a magic 'padding' statement.
1211 unsigned int alignment_needed = align_power(dot, power) - dot;
1213 if (alignment_needed != 0)
1215 lang_statement_union_type *new =
1216 (lang_statement_union_type *)
1217 ldmalloc(sizeof(lang_padding_statement_type));
1218 /* Link into existing chain */
1219 new->header.next = *this_ptr;
1221 new->header.type = lang_padding_statement_enum;
1222 new->padding_statement.output_section = output_section_statement;
1223 new->padding_statement.output_offset =
1224 dot - output_section_statement->vma;
1225 new->padding_statement.fill = fill;
1226 new->padding_statement.size = alignment_needed;
1230 /* Remember the most restrictive alignment */
1231 if (power > output_section_statement->alignment_power) {
1232 output_section_statement->alignment_power = power;
1234 output_section_statement->size += alignment_needed;
1235 return alignment_needed + dot;
1239 /* Work out how much this section will move the dot point */
1241 DEFUN(size_input_section, (this_ptr, output_section_statement, fill, dot),
1242 lang_statement_union_type **this_ptr AND
1243 lang_output_section_statement_type*output_section_statement AND
1244 unsigned short fill AND
1247 lang_input_section_type *is = &((*this_ptr)->input_section);
1248 asection *i = is->section;
1250 if (is->ifile->just_syms_flag == false) {
1251 dot = insert_pad(this_ptr, fill, i->alignment_power,
1252 output_section_statement->bfd_section, dot);
1254 /* remember the largest size so we can malloc the largest area */
1255 /* needed for the output stage */
1256 if (i->size > largest_section) {
1257 largest_section = i->size;
1260 /* Remember where in the output section this input section goes */
1262 i->output_offset = dot - output_section_statement->bfd_section->vma;
1264 /* Mark how big the output section must be to contain this now */
1266 output_section_statement->bfd_section->size =
1267 dot - output_section_statement->bfd_section->vma;
1271 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
1278 /* Work out the size of the output sections
1279 from the sizes of the input sections */
1281 DEFUN(lang_size_sections,(s, output_section_statement, prev, fill, dot),
1282 lang_statement_union_type *s AND
1283 lang_output_section_statement_type * output_section_statement AND
1284 lang_statement_union_type **prev AND
1285 unsigned short fill AND
1288 /* Size up the sections from their constituent parts */
1289 for (; s != (lang_statement_union_type *)NULL ; s = s->next)
1291 switch (s->header.type) {
1292 case lang_output_section_statement_enum:
1295 lang_output_section_statement_type *os =
1296 &(s->output_section_statement);
1297 /* The start of a section */
1299 if (os->addr_tree == (etree_type *)NULL) {
1300 /* No address specified for this section, get one
1301 from the region specification
1303 if (os->region == (lang_memory_region_type *)NULL) {
1304 os->region = lang_memory_region_lookup("*default*");
1306 dot = os->region->current;
1309 etree_value_type r ;
1310 r = exp_fold_tree(os->addr_tree,
1311 (lang_output_section_statement_type *)NULL,
1312 lang_allocating_phase_enum,
1314 if (r.valid == false) {
1315 info("%F%S: non constant address expression for section %s\n",
1320 /* The section starts here */
1321 /* First, align to what the section needs */
1323 dot = align_power(dot, os->bfd_section->alignment_power);
1324 os->bfd_section->vma = dot;
1325 os->bfd_section->output_offset = 0;
1327 (void) lang_size_sections(os->children.head, os, &os->children.head,
1329 /* Ignore the size of the input sections, use the vma and size to */
1333 after = ALIGN(os->bfd_section->vma +
1334 os->bfd_section->size,
1338 os->bfd_section->size = after - os->bfd_section->vma;
1339 dot = os->bfd_section->vma + os->bfd_section->size;
1340 os->processed = true;
1342 /* Replace into region ? */
1343 if (os->addr_tree == (etree_type *)NULL
1344 && os->region !=(lang_memory_region_type*)NULL ) {
1345 os->region->current = dot;
1351 case lang_data_statement_enum:
1354 s->data_statement.output_vma = dot;
1355 s->data_statement.output_section =
1356 output_section_statement->bfd_section;
1358 switch (s->data_statement.type) {
1371 output_section_statement->bfd_section->size += size;
1375 case lang_wild_statement_enum:
1377 dot = lang_size_sections(s->wild_statement.children.head,
1378 output_section_statement,
1379 &s->wild_statement.children.head,
1385 case lang_object_symbols_statement_enum:
1386 create_object_symbols = output_section_statement;
1388 case lang_output_statement_enum:
1389 case lang_target_statement_enum:
1391 case lang_input_section_enum:
1392 dot = size_input_section(prev,
1393 output_section_statement,
1394 output_section_statement->fill, dot);
1396 case lang_input_statement_enum:
1398 case lang_fill_statement_enum:
1399 fill = s->fill_statement.fill;
1401 case lang_assignment_statement_enum:
1403 bfd_vma newdot = dot;
1404 exp_fold_tree(s->assignment_statement.exp,
1405 output_section_statement,
1406 lang_allocating_phase_enum,
1411 /* We've been moved ! so insert a pad */
1413 lang_statement_union_type *new =
1414 (lang_statement_union_type *)
1415 ldmalloc(sizeof(lang_padding_statement_type));
1416 /* Link into existing chain */
1417 new->header.next = *prev;
1419 new->header.type = lang_padding_statement_enum;
1420 new->padding_statement.output_section =
1421 output_section_statement->bfd_section;
1422 new->padding_statement.output_offset =
1423 dot - output_section_statement->bfd_section->vma;
1424 new->padding_statement.fill = fill;
1425 new->padding_statement.size = newdot - dot;
1426 output_section_statement->bfd_section->size +=
1427 new->padding_statement.size;
1433 case lang_padding_statement_enum:
1439 case lang_address_statement_enum:
1442 prev = &s->header.next;
1449 DEFUN(lang_do_assignments,(s, output_section_statement, fill, dot),
1450 lang_statement_union_type *s AND
1451 lang_output_section_statement_type * output_section_statement AND
1452 unsigned short fill AND
1456 for (; s != (lang_statement_union_type *)NULL ; s = s->next)
1458 switch (s->header.type) {
1459 case lang_output_section_statement_enum:
1461 lang_output_section_statement_type *os =
1462 &(s->output_section_statement);
1463 dot = os->bfd_section->vma;
1464 (void) lang_do_assignments(os->children.head, os, os->fill, dot);
1465 dot = os->bfd_section->vma + os->bfd_section->size;
1468 case lang_wild_statement_enum:
1470 dot = lang_do_assignments(s->wild_statement.children.head,
1471 output_section_statement,
1476 case lang_object_symbols_statement_enum:
1477 case lang_output_statement_enum:
1478 case lang_target_statement_enum:
1480 case lang_common_statement_enum:
1483 case lang_data_statement_enum:
1485 etree_value_type value ;
1486 value = exp_fold_tree(s->data_statement.exp,
1487 0, lang_final_phase_enum, dot, &dot);
1488 s->data_statement.value = value.value;
1489 if (value.valid == false) info("%F%P: Invalid data statement\n");
1491 switch (s->data_statement.type) {
1503 case lang_input_section_enum:
1505 asection *in = s->input_section.section;
1510 case lang_input_statement_enum:
1512 case lang_fill_statement_enum:
1513 fill = s->fill_statement.fill;
1515 case lang_assignment_statement_enum:
1517 exp_fold_tree(s->assignment_statement.exp,
1518 output_section_statement,
1519 lang_final_phase_enum,
1525 case lang_padding_statement_enum:
1526 dot += s->padding_statement.size;
1531 case lang_address_statement_enum:
1542 DEFUN_VOID(lang_relocate_globals)
1546 Each ldsym_type maintains a chain of pointers to asymbols which
1547 references the definition. Replace each pointer to the referenence
1548 with a pointer to only one place, preferably the definition. If
1549 the defintion isn't available then the common symbol, and if
1550 there isn't one of them then choose one reference.
1553 FOR_EACH_LDSYM(lgs) {
1555 if (lgs->sdefs_chain) {
1556 it = *(lgs->sdefs_chain);
1558 else if (lgs->scoms_chain != (asymbol **)NULL) {
1559 it = *(lgs->scoms_chain);
1561 else if (lgs->srefs_chain != (asymbol **)NULL) {
1562 it = *(lgs->srefs_chain);
1565 /* This can happen when the command line asked for a symbol to
1567 it = (asymbol *)NULL;
1569 if (it != (asymbol *)NULL)
1571 asymbol **ptr= lgs->srefs_chain;
1573 while (ptr != (asymbol **)NULL) {
1574 asymbol *ref = *ptr;
1576 ptr = (asymbol **)(ref->udata);
1585 DEFUN_VOID(lang_finish)
1589 if (entry_symbol == (char *)NULL) {
1590 /* No entry has been specified, look for start */
1591 entry_symbol = "start";
1593 lgs = ldsym_get_soft(entry_symbol);
1594 if (lgs && lgs->sdefs_chain) {
1595 asymbol *sy = *(lgs->sdefs_chain);
1596 /* We can set the entry address*/
1597 bfd_set_start_address(output_bfd,
1598 outside_symbol_address(sy));
1602 /* Can't find anything reasonable,
1603 use the first address in the text section
1605 asection *ts = bfd_get_section_by_name(output_bfd, ".text");
1607 bfd_set_start_address(output_bfd, ts->vma);
1612 /* By now we know the target architecture, and we may have an */
1613 /* ldfile_output_machine_name */
1615 DEFUN_VOID(lang_check)
1617 lang_statement_union_type *file;
1620 for (file = file_chain.head;
1621 file != (lang_statement_union_type *)NULL;
1622 file=file->input_statement.next)
1624 /* Inspect the architecture and ensure we're linking like
1628 if (bfd_arch_compatible( file->input_statement.the_bfd,
1630 &ldfile_output_architecture,
1631 &ldfile_output_machine)) {
1632 bfd_set_arch_mach(output_bfd,
1633 ldfile_output_architecture, ldfile_output_machine);
1636 enum bfd_architecture this_architecture =
1637 bfd_get_architecture(file->input_statement.the_bfd);
1638 unsigned long this_machine =
1639 bfd_get_machine(file->input_statement.the_bfd);
1641 info("%I: architecture %s",
1643 bfd_printable_arch_mach(this_architecture, this_machine));
1644 info(" incompatible with output %s\n",
1645 bfd_printable_arch_mach(ldfile_output_architecture,
1646 ldfile_output_machine));
1647 ldfile_output_architecture = this_architecture;
1648 ldfile_output_machine = this_machine;
1649 bfd_set_arch_mach(output_bfd,
1650 ldfile_output_architecture,
1651 ldfile_output_machine);
1660 * run through all the global common symbols and tie them
1661 * to the output section requested.
1665 DEFUN_VOID(lang_common)
1668 if (config.relocateable_output == false ||
1669 command_line.force_common_definition== true) {
1670 for (lgs = symbol_head;
1671 lgs != (ldsym_type *)NULL;
1675 unsigned int power_of_two;
1678 if (lgs->scoms_chain != (asymbol **)NULL) {
1679 com = *(lgs->scoms_chain);
1710 /* Change from a common symbol into a definition of
1712 lgs->sdefs_chain = lgs->scoms_chain;
1713 lgs->scoms_chain = (asymbol **)NULL;
1715 /* Point to the correct common section */
1717 ((lang_input_statement_type *)
1718 (com->the_bfd->usrdata))->common_section;
1719 /* Fix the size of the common section */
1720 com->section->size = ALIGN(com->section->size, align);
1722 /* Remember if this is the biggest alignment ever seen */
1723 if (power_of_two > com->section->alignment_power) {
1724 com->section->alignment_power = power_of_two;
1727 /* Symbol stops being common and starts being global, but
1728 we remember that it was common once. */
1730 com->flags = BSF_EXPORT | BSF_GLOBAL | BSF_OLD_COMMON;
1735 printf ("Allocating common %s: %x at %x\n",
1738 (unsigned) com->section->size);
1740 com->value = com->section->size;
1741 com->section->size += size;
1752 run through the input files and ensure that every input
1753 section has somewhere to go. If one is found without
1754 a destination then create an input request and place it
1755 into the statement tree.
1759 DEFUN_VOID(lang_place_orphans)
1761 lang_input_statement_type *file;
1762 for (file = (lang_input_statement_type*)file_chain.head;
1763 file != (lang_input_statement_type*)NULL;
1764 file = (lang_input_statement_type*)file->next) {
1766 for (s = file->the_bfd->sections;
1767 s != (asection *)NULL;
1769 if ( s->output_section == (asection *)NULL) {
1770 /* This section of the file is not attatched, root
1771 around for a sensible place for it to go */
1773 if (file->common_section == s) {
1774 /* This is a lonely common section which must
1775 have come from an archive. We attatch to the
1776 section with the wildcard */
1777 if (config.relocateable_output != true
1778 && command_line.force_common_definition == false) {
1779 if (default_common_section ==
1780 (lang_output_section_statement_type *)NULL) {
1781 info("%P: No [COMMON] command, defaulting to .bss\n");
1783 default_common_section =
1784 lang_output_section_statement_lookup(".bss");
1787 wild_doit(&default_common_section->children, s,
1788 default_common_section, file);
1792 lang_output_section_statement_type *os =
1793 lang_output_section_statement_lookup(s->name);
1795 wild_doit(&os->children, s, os, file);
1804 DEFUN(lang_set_flags,(ptr, flags),
1805 lang_section_flags_type *ptr AND
1808 boolean state = true;
1809 ptr->flag_read = false;
1810 ptr->flag_write = false;
1811 ptr->flag_executable = false;
1812 ptr->flag_loadable= false;
1815 if (*flags == '!') {
1822 ptr->flag_read = state;
1825 ptr->flag_write = state;
1828 ptr->flag_executable= state;
1831 ptr->flag_loadable= state;
1834 info("%P%F illegal syntax in flags\n");
1844 DEFUN(lang_for_each_file,(func),
1845 PROTO(void, (*func),(lang_input_statement_type *)))
1847 lang_input_statement_type *f;
1848 for (f = (lang_input_statement_type *)file_chain.head;
1849 f != (lang_input_statement_type *)NULL;
1850 f = (lang_input_statement_type *)f->next)
1858 DEFUN(lang_for_each_input_section, (func),
1859 PROTO(void ,(*func),(bfd *ab, asection*as)))
1861 lang_input_statement_type *f;
1862 for (f = (lang_input_statement_type *)file_chain.head;
1863 f != (lang_input_statement_type *)NULL;
1864 f = (lang_input_statement_type *)f->next)
1867 for (s = f->the_bfd->sections;
1868 s != (asection *)NULL;
1870 func(f->the_bfd, s);
1878 DEFUN(ldlang_add_file,(entry),
1879 lang_input_statement_type *entry)
1882 lang_statement_append(&file_chain,
1883 (lang_statement_union_type *)entry,
1890 DEFUN(lang_add_output,(name),
1893 lang_output_statement_type *new = new_stat(lang_output_statement,
1896 had_output_filename = true;
1900 static lang_output_section_statement_type *current_section;
1903 DEFUN(lang_enter_output_section_statement,
1904 (output_section_statement_name,
1907 char *output_section_statement_name AND
1908 etree_type *address_exp AND
1909 bfd_vma block_value)
1911 lang_output_section_statement_type *os;
1914 lang_output_section_statement_lookup(output_section_statement_name);
1917 /* Add this statement to tree */
1918 /* add_statement(lang_output_section_statement_enum,
1919 output_section_statement);*/
1920 /* Make next things chain into subchain of this */
1922 if (os->addr_tree ==
1923 (etree_type *)NULL) {
1927 os->block_value = block_value;
1928 stat_ptr = & os->children;
1934 DEFUN_VOID(lang_final)
1936 if (had_output_filename == false) {
1937 lang_add_output("a.out");
1946 DEFUN(create_symbol,(name, flags, section),
1947 CONST char *name AND
1951 extern lang_input_statement_type *script_file;
1952 asymbol **def_ptr = (asymbol **)ldmalloc(sizeof(asymbol **));
1953 /* Add this definition to script file */
1954 asymbol *def = (asymbol *)bfd_make_empty_symbol(script_file->the_bfd);
1955 def->name = buystring(name);
1958 def->section = section;
1961 Q_enter_global_ref(def_ptr);
1967 DEFUN_VOID(lang_process)
1969 if (had_script == false) {
1970 parse_line(ldemul_get_script());
1972 lang_reasonable_defaults();
1973 current_target = default_target;
1975 lang_for_each_statement(ldlang_open_output); /* Open the output file */
1976 /* For each output section statement, create a section in the output
1978 lang_create_output_section_statements();
1980 /* Create a dummy bfd for the script */
1981 lang_init_script_file();
1983 /* Add to the hash table all undefineds on the command line */
1984 lang_place_undefineds();
1986 /* Create a bfd for each input file */
1987 current_target = default_target;
1988 lang_for_each_statement(open_input_bfds);
1990 common_section.userdata = &common_section_userdata;
1992 /* Run through the contours of the script and attatch input sections
1993 to the correct output sections
1995 map_input_to_output_sections(statement_list.head, (char *)NULL,
1996 ( lang_output_section_statement_type *)NULL);
1998 /* Find any sections not attatched explicitly and handle them */
1999 lang_place_orphans();
2001 /* Size up the common data */
2004 ldemul_before_allocation();
2006 /* Size up the sections */
2007 lang_size_sections(statement_list.head,
2008 (lang_output_section_statement_type *)NULL,
2009 &(statement_list.head), 0, (bfd_vma)0);
2011 /* See if anything special should be done now we know how big
2013 ldemul_after_allocation();
2015 /* Do all the assignments, now that we know the final restingplaces
2016 of all the symbols */
2018 lang_do_assignments(statement_list.head,
2019 (lang_output_section_statement_type *)NULL,
2022 /* Make sure that we're not mixing architectures */
2026 /* Move the global symbols around */
2027 lang_relocate_globals();
2034 /* EXPORTED TO YACC */
2037 DEFUN(lang_add_wild,(section_name, filename),
2038 CONST char *CONST section_name AND
2039 CONST char *CONST filename)
2041 lang_wild_statement_type *new = new_stat(lang_wild_statement,
2044 if (section_name != (char *)NULL && strcmp(section_name,"COMMON") == 0)
2046 placed_commons = true;
2048 if (filename != (char *)NULL) {
2049 lang_has_input_file = true;
2051 new->section_name = section_name;
2052 new->filename = filename;
2053 lang_list_init(&new->children);
2056 DEFUN(lang_section_start,(name, address),
2057 CONST char *name AND
2058 etree_type *address)
2060 lang_address_statement_type *ad =new_stat(lang_address_statement, stat_ptr);
2061 ad->section_name = name;
2062 ad->address = address;
2066 DEFUN(lang_add_entry,(name),
2069 entry_symbol = name;
2073 DEFUN(lang_add_target,(name),
2076 lang_target_statement_type *new = new_stat(lang_target_statement,
2086 DEFUN(lang_add_map,(name),
2092 map_option_f = true;
2100 DEFUN(lang_add_fill,(exp),
2103 lang_fill_statement_type *new = new_stat(lang_fill_statement,
2109 DEFUN(lang_add_data,(type, exp),
2111 union etree_union *exp)
2114 lang_data_statement_type *new = new_stat(lang_data_statement,
2121 DEFUN(lang_add_assignment,(exp),
2124 lang_assignment_statement_type *new = new_stat(lang_assignment_statement,
2130 DEFUN(lang_add_attribute,(attribute),
2131 enum statement_enum attribute)
2133 new_statement(attribute, sizeof(lang_statement_union_type),stat_ptr);
2139 DEFUN(lang_startup,(name),
2142 if (startup_file != (char *)NULL) {
2143 info("%P%FMultiple STARTUP files\n");
2145 first_file->filename = name;
2146 first_file->local_sym_name = name;
2151 DEFUN(lang_float,(maybe),
2154 lang_float_flag = maybe;
2158 DEFUN(lang_leave_output_section_statement,(fill, memspec),
2160 CONST char *memspec)
2162 current_section->fill = fill;
2163 current_section->region = lang_memory_region_lookup(memspec);
2164 stat_ptr = &statement_list;
2167 Create an absolute symbol with the given name with the value of the
2168 address of first byte of the section named.
2170 If the symbol already exists, then do nothing.
2173 DEFUN(lang_abs_symbol_at_beginning_of,(section, name),
2174 CONST char *section AND
2177 if (ldsym_undefined(name)) {
2178 extern bfd *output_bfd;
2179 extern asymbol *create_symbol();
2180 asection *s = bfd_get_section_by_name(output_bfd, section);
2181 asymbol *def = create_symbol(name,
2182 BSF_GLOBAL | BSF_EXPORT |
2185 if (s != (asection *)NULL) {
2186 def->value = s->vma;
2195 Create an absolute symbol with the given name with the value of the
2196 address of the first byte after the end of the section named.
2198 If the symbol already exists, then do nothing.
2201 DEFUN(lang_abs_symbol_at_end_of,(section, name),
2202 CONST char *section AND
2205 if (ldsym_undefined(name)){
2206 extern bfd *output_bfd;
2207 extern asymbol *create_symbol();
2208 asection *s = bfd_get_section_by_name(output_bfd, section);
2209 /* Add a symbol called _end */
2210 asymbol *def = create_symbol(name,
2211 BSF_GLOBAL | BSF_EXPORT |
2214 if (s != (asection *)NULL) {
2215 def->value = s->vma + s->size;
2224 DEFUN(lang_statement_append,(list, element, field),
2225 lang_statement_list_type *list AND
2226 lang_statement_union_type *element AND
2227 lang_statement_union_type **field)
2229 *(list->tail) = element;
2233 /* Set the output format type */
2235 DEFUN(lang_add_output_format,(format),
2238 output_target = format;