projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* ldlang.c (print_output_section_statement): Change ``no attached
[binutils-gdb.git] / ld / ldlang.c
1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94 Free Software Foundation, Inc.
3
4 This file is part of GLD, the Gnu Linker.
5
6 GLD is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
9 any later version.
10
11 GLD is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GLD; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "libiberty.h"
23 #include "bfdlink.h"
24
25 #include "ld.h"
26 #include "ldmain.h"
27 #include "ldgram.h"
28 #include "ldexp.h"
29 #include "ldlang.h"
30 #include "ldemul.h"
31 #include "ldlex.h"
32 #include "ldmisc.h"
33 #include "ldctor.h"
34 #include "ldfile.h"
35
36 /* FORWARDS */
37 static void print_statements PARAMS ((void));
38 static void print_statement PARAMS ((lang_statement_union_type *,
39 lang_output_section_statement_type *));
40 static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
41 size_t,
42 lang_statement_list_type*));
43
44
45 /* LOCALS */
46 static struct obstack stat_obstack;
47
48 #define obstack_chunk_alloc xmalloc
49 #define obstack_chunk_free free
50 static CONST char *startup_file;
51 static lang_statement_list_type input_file_chain;
52
53 /* Points to the last statement in the .data section, so we can add
54 stuff to the data section without pain */
55 static lang_statement_list_type end_of_data_section_statement_list;
56
57 static boolean placed_commons = false;
58 static lang_output_section_statement_type *default_common_section;
59 static boolean map_option_f;
60 static bfd_vma print_dot;
61 static lang_input_statement_type *first_file;
62 static lang_statement_list_type lang_output_section_statement;
63 static CONST char *current_target;
64 static CONST char *output_target;
65 static int longest_section_name = 8;
66 static lang_statement_list_type statement_list;
67
68 static void print_size PARAMS ((size_t value));
69 static void print_alignment PARAMS ((unsigned int value));
70 static void print_fill PARAMS ((fill_type value));
71 static void print_section PARAMS ((const char *name));
72 static void lang_for_each_statement_worker
73 PARAMS ((void (*func) (lang_statement_union_type *),
74 lang_statement_union_type *s));
75 static lang_input_statement_type *new_afile
76 PARAMS ((const char *name, lang_input_file_enum_type file_type,
77 const char *target, boolean add_to_list));
78 static void print_flags PARAMS ((int *ignore_flags));
79 static void init_os PARAMS ((lang_output_section_statement_type *s));
80 static void wild_doit PARAMS ((lang_statement_list_type *ptr,
81 asection *section,
82 lang_output_section_statement_type *output,
83 lang_input_statement_type *file));
84 static void wild_section PARAMS ((lang_wild_statement_type *ptr,
85 const char *section,
86 lang_input_statement_type *file,
87 lang_output_section_statement_type *output));
88 static lang_input_statement_type *lookup_name PARAMS ((const char *name));
89 static void load_symbols PARAMS ((lang_input_statement_type *entry));
90 static void wild PARAMS ((lang_wild_statement_type *s,
91 const char *section, const char *file,
92 const char *target,
93 lang_output_section_statement_type *output));
94 static bfd *open_output PARAMS ((const char *name));
95 static void ldlang_open_output PARAMS ((lang_statement_union_type *statement));
96 static void open_input_bfds PARAMS ((lang_statement_union_type *statement));
97 static void lang_reasonable_defaults PARAMS ((void));
98 static void lang_place_undefineds PARAMS ((void));
99 static void map_input_to_output_sections
100 PARAMS ((lang_statement_union_type *s,
101 const char *target,
102 lang_output_section_statement_type *output_section_statement));
103 static void print_output_section_statement
104 PARAMS ((lang_output_section_statement_type *output_section_statement));
105 static void print_assignment
106 PARAMS ((lang_assignment_statement_type *assignment,
107 lang_output_section_statement_type *output_section));
108 static void print_input_statement PARAMS ((lang_input_statement_type *statm));
109 static void print_input_section PARAMS ((lang_input_section_type *in));
110 static void print_fill_statement PARAMS ((lang_fill_statement_type *fill));
111 static void print_data_statement PARAMS ((lang_data_statement_type *data));
112 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *reloc));
113 static void print_padding_statement PARAMS ((lang_padding_statement_type *s));
114 static void print_wild_statement
115 PARAMS ((lang_wild_statement_type *w,
116 lang_output_section_statement_type *os));
117 static void print_statement PARAMS ((lang_statement_union_type *s,
118 lang_output_section_statement_type *os));
119 static void print_statements PARAMS ((void));
120 static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr,
121 fill_type fill, unsigned int power,
122 asection *output_section_statement,
123 bfd_vma dot));
124 static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type **this_ptr,
126 lang_output_section_statement_type *output_section_statement,
127 fill_type fill, bfd_vma dot, boolean relax));
128 static bfd_vma lang_do_assignments
129 PARAMS ((lang_statement_union_type * s,
130 lang_output_section_statement_type *output_section_statement,
131 fill_type fill,
132 bfd_vma dot));
133 static void lang_finish PARAMS ((void));
134 static void lang_check PARAMS ((void));
135 static void lang_common PARAMS ((void));
136 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
137 static void lang_place_orphans PARAMS ((void));
138 static int topower PARAMS ((int));
139 static void reset_memory_regions PARAMS ((void));
140
141 /* EXPORTS */
142 lang_output_section_statement_type *abs_output_section;
143 lang_statement_list_type *stat_ptr = &statement_list;
144 lang_statement_list_type file_chain =
145 {0};
146 CONST char *entry_symbol = 0;
147 boolean lang_has_input_file = false;
148 boolean had_output_filename = false;
149 boolean lang_float_flag = false;
150 boolean delete_output_file_on_failure = false;
151
152 etree_type *base; /* Relocation base - or null */
153
154
155 #if defined(__STDC__) || defined(ALMOST_STDC)
156 #define cat(a,b) a##b
157 #else
158 #define cat(a,b) a/**/b
159 #endif
160
161 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
162
163 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
164
165 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
166
167 PTR
168 stat_alloc (size)
169 size_t size;
170 {
171 return obstack_alloc (&stat_obstack, size);
172 }
173
174 static void
175 print_size (value)
176 size_t value;
177 {
178 fprintf (config.map_file, "%5x", (unsigned) value);
179 }
180
181 static void
182 print_alignment (value)
183 unsigned int value;
184 {
185 fprintf (config.map_file, "2**%1u", value);
186 }
187
188 static void
189 print_fill (value)
190 fill_type value;
191 {
192 fprintf (config.map_file, "%04x", (unsigned) value);
193 }
194
195 static void
196 print_section (name)
197 CONST char *name;
198 {
199 fprintf (config.map_file, "%*s", -longest_section_name, name);
200 }
201
202 /*----------------------------------------------------------------------
203 lang_for_each_statement walks the parse tree and calls the provided
204 function for each node
205 */
206
207 static void
208 lang_for_each_statement_worker (func, s)
209 void (*func) PARAMS ((lang_statement_union_type *));
210 lang_statement_union_type *s;
211 {
212 for (; s != (lang_statement_union_type *) NULL; s = s->next)
213 {
214 func (s);
215
216 switch (s->header.type)
217 {
218 case lang_constructors_statement_enum:
219 lang_for_each_statement_worker (func, constructor_list.head);
220 break;
221 case lang_output_section_statement_enum:
222 lang_for_each_statement_worker
223 (func,
224 s->output_section_statement.children.head);
225 break;
226 case lang_wild_statement_enum:
227 lang_for_each_statement_worker
228 (func,
229 s->wild_statement.children.head);
230 break;
231 case lang_data_statement_enum:
232 case lang_reloc_statement_enum:
233 case lang_object_symbols_statement_enum:
234 case lang_output_statement_enum:
235 case lang_target_statement_enum:
236 case lang_input_section_enum:
237 case lang_input_statement_enum:
238 case lang_assignment_statement_enum:
239 case lang_padding_statement_enum:
240 case lang_address_statement_enum:
241 break;
242 default:
243 FAIL ();
244 break;
245 }
246 }
247 }
248
249 void
250 lang_for_each_statement (func)
251 void (*func) PARAMS ((lang_statement_union_type *));
252 {
253 lang_for_each_statement_worker (func,
254 statement_list.head);
255 }
256
257 /*----------------------------------------------------------------------*/
258 void
259 lang_list_init (list)
260 lang_statement_list_type *list;
261 {
262 list->head = (lang_statement_union_type *) NULL;
263 list->tail = &list->head;
264 }
265
266 /*----------------------------------------------------------------------
267
268 build a new statement node for the parse tree
269
270 */
271
272 static
273 lang_statement_union_type *
274 new_statement (type, size, list)
275 enum statement_enum type;
276 size_t size;
277 lang_statement_list_type * list;
278 {
279 lang_statement_union_type *new = (lang_statement_union_type *)
280 stat_alloc (size);
281
282 new->header.type = type;
283 new->header.next = (lang_statement_union_type *) NULL;
284 lang_statement_append (list, new, &new->header.next);
285 return new;
286 }
287
288 /*
289 Build a new input file node for the language. There are several ways
290 in which we treat an input file, eg, we only look at symbols, or
291 prefix it with a -l etc.
292
293 We can be supplied with requests for input files more than once;
294 they may, for example be split over serveral lines like foo.o(.text)
295 foo.o(.data) etc, so when asked for a file we check that we havn't
296 got it already so we don't duplicate the bfd.
297
298 */
299 static lang_input_statement_type *
300 new_afile (name, file_type, target, add_to_list)
301 CONST char *name;
302 lang_input_file_enum_type file_type;
303 CONST char *target;
304 boolean add_to_list;
305 {
306 lang_input_statement_type *p;
307
308 if (add_to_list)
309 p = new_stat (lang_input_statement, stat_ptr);
310 else
311 {
312 p = ((lang_input_statement_type *)
313 stat_alloc (sizeof (lang_input_statement_type)));
314 p->header.next = NULL;
315 }
316
317 lang_has_input_file = true;
318 p->target = target;
319 p->complained = false;
320 switch (file_type)
321 {
322 case lang_input_file_is_symbols_only_enum:
323 p->filename = name;
324 p->is_archive = false;
325 p->real = true;
326 p->local_sym_name = name;
327 p->just_syms_flag = true;
328 p->search_dirs_flag = false;
329 break;
330 case lang_input_file_is_fake_enum:
331 p->filename = name;
332 p->is_archive = false;
333 p->real = false;
334 p->local_sym_name = name;
335 p->just_syms_flag = false;
336 p->search_dirs_flag = false;
337 break;
338 case lang_input_file_is_l_enum:
339 p->is_archive = true;
340 p->filename = name;
341 p->real = true;
342 p->local_sym_name = concat ("-l", name, (const char *) NULL);
343 p->just_syms_flag = false;
344 p->search_dirs_flag = true;
345 break;
346 case lang_input_file_is_marker_enum:
347 p->filename = name;
348 p->is_archive = false;
349 p->real = false;
350 p->local_sym_name = name;
351 p->just_syms_flag = false;
352 p->search_dirs_flag = true;
353 break;
354 case lang_input_file_is_search_file_enum:
355 p->filename = name;
356 p->is_archive = false;
357 p->real = true;
358 p->local_sym_name = name;
359 p->just_syms_flag = false;
360 p->search_dirs_flag = true;
361 break;
362 case lang_input_file_is_file_enum:
363 p->filename = name;
364 p->is_archive = false;
365 p->real = true;
366 p->local_sym_name = name;
367 p->just_syms_flag = false;
368 p->search_dirs_flag = false;
369 break;
370 default:
371 FAIL ();
372 }
373 p->the_bfd = (bfd *) NULL;
374 p->asymbols = (asymbol **) NULL;
375 p->superfile = (lang_input_statement_type *) NULL;
376 p->next_real_file = (lang_statement_union_type *) NULL;
377 p->next = (lang_statement_union_type *) NULL;
378 p->symbol_count = 0;
379 p->common_output_section = (asection *) NULL;
380 p->loaded = false;
381 lang_statement_append (&input_file_chain,
382 (lang_statement_union_type *) p,
383 &p->next_real_file);
384 return p;
385 }
386
387 lang_input_statement_type *
388 lang_add_input_file (name, file_type, target)
389 CONST char *name;
390 lang_input_file_enum_type file_type;
391 CONST char *target;
392 {
393 /* Look it up or build a new one */
394 lang_has_input_file = true;
395
396 #if 0
397 lang_input_statement_type *p;
398
399 for (p = (lang_input_statement_type *) input_file_chain.head;
400 p != (lang_input_statement_type *) NULL;
401 p = (lang_input_statement_type *) (p->next_real_file))
402 {
403 /* Sometimes we have incomplete entries in here */
404 if (p->filename != (char *) NULL)
405 {
406 if (strcmp (name, p->filename) == 0)
407 return p;
408 }
409
410 }
411 #endif
412 return new_afile (name, file_type, target, true);
413 }
414
415 /* Build enough state so that the parser can build its tree */
416 void
417 lang_init ()
418 {
419 obstack_begin (&stat_obstack, 1000);
420
421 stat_ptr = &statement_list;
422
423 lang_list_init (stat_ptr);
424
425 lang_list_init (&input_file_chain);
426 lang_list_init (&lang_output_section_statement);
427 lang_list_init (&file_chain);
428 first_file = lang_add_input_file ((char *) NULL,
429 lang_input_file_is_marker_enum,
430 (char *) NULL);
431 abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
432
433 abs_output_section->bfd_section = &bfd_abs_section;
434
435 }
436
437 /*----------------------------------------------------------------------
438 A region is an area of memory declared with the
439 MEMORY { name:org=exp, len=exp ... }
440 syntax.
441
442 We maintain a list of all the regions here
443
444 If no regions are specified in the script, then the default is used
445 which is created when looked up to be the entire data space
446 */
447
448 static lang_memory_region_type *lang_memory_region_list;
449 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
450
451 lang_memory_region_type *
452 lang_memory_region_lookup (name)
453 CONST char *CONST name;
454 {
455
456 lang_memory_region_type *p = lang_memory_region_list;
457
458 for (p = lang_memory_region_list;
459 p != (lang_memory_region_type *) NULL;
460 p = p->next)
461 {
462 if (strcmp (p->name, name) == 0)
463 {
464 return p;
465 }
466 }
467 if (strcmp (name, "*default*") == 0)
468 {
469 /* This is the default region, dig out first one on the list */
470 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
471 {
472 return lang_memory_region_list;
473 }
474 }
475 {
476 lang_memory_region_type *new =
477 (lang_memory_region_type *) stat_alloc ((bfd_size_type) (sizeof (lang_memory_region_type)));
478
479 new->name = buystring (name);
480 new->next = (lang_memory_region_type *) NULL;
481
482 *lang_memory_region_list_tail = new;
483 lang_memory_region_list_tail = &new->next;
484 new->origin = 0;
485 new->length = ~(bfd_size_type)0;
486 new->current = 0;
487 new->had_full_message = false;
488
489 return new;
490 }
491 }
492
493
494 lang_output_section_statement_type *
495 lang_output_section_find (name)
496 CONST char *CONST name;
497 {
498 lang_statement_union_type *u;
499 lang_output_section_statement_type *lookup;
500
501 for (u = lang_output_section_statement.head;
502 u != (lang_statement_union_type *) NULL;
503 u = lookup->next)
504 {
505 lookup = &u->output_section_statement;
506 if (strcmp (name, lookup->name) == 0)
507 {
508 return lookup;
509 }
510 }
511 return (lang_output_section_statement_type *) NULL;
512 }
513
514 lang_output_section_statement_type *
515 lang_output_section_statement_lookup (name)
516 CONST char *CONST name;
517 {
518 lang_output_section_statement_type *lookup;
519
520 lookup = lang_output_section_find (name);
521 if (lookup == (lang_output_section_statement_type *) NULL)
522 {
523
524 lookup = (lang_output_section_statement_type *)
525 new_stat (lang_output_section_statement, stat_ptr);
526 lookup->region = (lang_memory_region_type *) NULL;
527 lookup->fill = 0;
528 lookup->block_value = 1;
529 lookup->name = name;
530
531 lookup->next = (lang_statement_union_type *) NULL;
532 lookup->bfd_section = (asection *) NULL;
533 lookup->processed = false;
534 lookup->loadable = 1;
535 lookup->addr_tree = (etree_type *) NULL;
536 lang_list_init (&lookup->children);
537
538 lookup->memspec = (CONST char *) NULL;
539 lookup->flags = 0;
540 lookup->subsection_alignment = -1;
541 lookup->section_alignment = -1;
542 lookup->load_base = (union etree_union *) NULL;
543
544 lang_statement_append (&lang_output_section_statement,
545 (lang_statement_union_type *) lookup,
546 &lookup->next);
547 }
548 return lookup;
549 }
550
551 /*ARGSUSED*/
552 static void
553 print_flags (ignore_flags)
554 int *ignore_flags;
555 {
556 fprintf (config.map_file, "(");
557 #if 0
558 if (flags->flag_read)
559 fprintf (outfile, "R");
560 if (flags->flag_write)
561 fprintf (outfile, "W");
562 if (flags->flag_executable)
563 fprintf (outfile, "X");
564 if (flags->flag_loadable)
565 fprintf (outfile, "L");
566 #endif
567 fprintf (config.map_file, ")");
568 }
569
570 void
571 lang_map ()
572 {
573 lang_memory_region_type *m;
574
575 fprintf (config.map_file, "**MEMORY CONFIGURATION**\n\n");
576 #ifdef HOST_64_BIT
577 fprintf (config.map_file, "name\t\torigin\t\tlength\t\tattributes\n");
578 #else
579 fprintf (config.map_file,
580 "name\t\torigin length r_size c_size is attributes\n");
581
582 #endif
583 for (m = lang_memory_region_list;
584 m != (lang_memory_region_type *) NULL;
585 m = m->next)
586 {
587 fprintf (config.map_file, "%-16s", m->name);
588 print_address (m->origin);
589 print_space ();
590 print_address ((bfd_vma)m->length);
591 print_space ();
592 print_address ((bfd_vma)m->old_length);
593 print_space();
594 print_address (m->current - m->origin);
595 print_space();
596 if (m->old_length)
597 fprintf (config.map_file, " %2d%% ",
598 (int) ((m->current - m->origin) * 100 / m->old_length));
599 print_flags (&m->flags);
600 fprintf (config.map_file, "\n");
601 }
602 fprintf (config.map_file, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
603 fprintf (config.map_file, "output input virtual\n");
604 fprintf (config.map_file, "section section address tsize\n\n");
605
606 print_statements ();
607
608 }
609
610 /*
611 *
612 */
613 static void
614 init_os (s)
615 lang_output_section_statement_type * s;
616 {
617 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
618 section_userdata_type *new =
619 (section_userdata_type *)
620 stat_alloc ((bfd_size_type) (sizeof (section_userdata_type)));
621
622 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
623 if (s->bfd_section == (asection *) NULL)
624 s->bfd_section = bfd_make_section (output_bfd, s->name);
625 if (s->bfd_section == (asection *) NULL)
626 {
627 einfo ("%P%F: output format %s cannot represent section called %s\n",
628 output_bfd->xvec->name, s->name);
629 }
630 s->bfd_section->output_section = s->bfd_section;
631 /* s->bfd_section->flags = s->flags;*/
632
633 /* We initialize an output sections output offset to minus its own */
634 /* vma to allow us to output a section through itself */
635 s->bfd_section->output_offset = 0;
636 get_userdata (s->bfd_section) = (PTR) new;
637
638 }
639
640 /***********************************************************************
641 The wild routines.
642
643 These expand statements like *(.text) and foo.o to a list of
644 explicit actions, like foo.o(.text), bar.o(.text) and
645 foo.o(.text,.data) .
646
647 The toplevel routine, wild, takes a statement, section, file and
648 target. If either the section or file is null it is taken to be the
649 wildcard. Seperate lang_input_section statements are created for
650 each part of the expanstion, and placed after the statement provided.
651
652 */
653
654 static void
655 wild_doit (ptr, section, output, file)
656 lang_statement_list_type * ptr;
657 asection * section;
658 lang_output_section_statement_type * output;
659 lang_input_statement_type * file;
660 {
661 if (output->bfd_section == (asection *) NULL)
662 init_os (output);
663
664 if (section != (asection *) NULL
665 && section->output_section == (asection *) NULL)
666 {
667 /* Add a section reference to the list */
668 lang_input_section_type *new = new_stat (lang_input_section, ptr);
669
670 new->section = section;
671 new->ifile = file;
672 section->output_section = output->bfd_section;
673
674 /* We don't copy the SEC_NEVER_LOAD flag from an input section to
675 an output section, because we want to be able to include a
676 SEC_NEVER_LOAD section in the middle of an otherwise loaded
677 section (I don't know why we want to do this, but we do).
678 build_link_order in ldwrite.c handles this case by turning the
679 embedded SEC_NEVER_LOAD section into a fill. */
680 section->output_section->flags |=
681 section->flags & (flagword) (~ SEC_NEVER_LOAD);
682
683 if (!output->loadable)
684 {
685 /* Turn off load flag */
686 output->bfd_section->flags &= ~SEC_LOAD;
687 output->bfd_section->flags |= SEC_NEVER_LOAD;
688 }
689 if (section->alignment_power > output->bfd_section->alignment_power)
690 {
691 output->bfd_section->alignment_power = section->alignment_power;
692 }
693 /* If supplied an aligmnet, then force it */
694 if (output->section_alignment != -1)
695 {
696 output->bfd_section->alignment_power = output->section_alignment;
697 }
698 }
699 }
700
701 static void
702 wild_section (ptr, section, file, output)
703 lang_wild_statement_type * ptr;
704 CONST char *section;
705 lang_input_statement_type * file;
706 lang_output_section_statement_type * output;
707 {
708 asection *s;
709
710 if (file->just_syms_flag == false)
711 {
712 if (section == (char *) NULL)
713 {
714 /* Do the creation to all sections in the file */
715 for (s = file->the_bfd->sections; s != NULL; s = s->next)
716 {
717 /* except for bss */
718 if ((s->flags & SEC_IS_COMMON) == 0)
719 {
720 wild_doit (&ptr->children, s, output, file);
721 }
722 }
723 }
724 else
725 {
726 /* Do the creation to the named section only */
727 s = bfd_get_section_by_name (file->the_bfd, section);
728 if (s != NULL)
729 wild_doit (&ptr->children, s, output, file);
730 }
731 }
732 }
733
734 /* passed a file name (which must have been seen already and added to
735 the statement tree. We will see if it has been opened already and
736 had its symbols read. If not then we'll read it.
737
738 Archives are pecuilar here. We may open them once, but if they do
739 not define anything we need at the time, they won't have all their
740 symbols read. If we need them later, we'll have to redo it.
741 */
742 static lang_input_statement_type *
743 lookup_name (name)
744 CONST char *name;
745 {
746 lang_input_statement_type *search;
747
748 for (search = (lang_input_statement_type *) input_file_chain.head;
749 search != (lang_input_statement_type *) NULL;
750 search = (lang_input_statement_type *) search->next_real_file)
751 {
752 if (search->filename == (char *) NULL && name == (char *) NULL)
753 return search;
754 if (search->filename != (char *) NULL
755 && name != (char *) NULL
756 && strcmp (search->filename, name) == 0)
757 break;
758 }
759
760 if (search == (lang_input_statement_type *) NULL)
761 search = new_afile (name, lang_input_file_is_file_enum, default_target,
762 false);
763
764 /* If we have already added this file, or this file is not real
765 (FIXME: can that ever actually happen?) or the name is NULL
766 (FIXME: can that ever actually happen?) don't add this file. */
767 if (search->loaded
768 || ! search->real
769 || search->filename == (const char *) NULL)
770 return search;
771
772 load_symbols (search);
773
774 return search;
775 }
776
777 /* Get the symbols for an input file. */
778
779 static void
780 load_symbols (entry)
781 lang_input_statement_type *entry;
782 {
783 if (entry->loaded)
784 return;
785
786 ldfile_open_file (entry);
787
788 if (bfd_check_format (entry->the_bfd, bfd_object))
789 {
790 ldlang_add_file (entry);
791 if (trace_files || trace_file_tries)
792 info_msg ("%I\n", entry);
793 }
794 else if (bfd_check_format (entry->the_bfd, bfd_archive))
795 {
796 /* There is nothing to do here; the add_symbols routine will
797 call ldlang_add_file (via the add_archive_element callback)
798 for each element of the archive which is used. */
799 }
800 else
801 einfo ("%F%B: file not recognized: %E\n", entry->the_bfd);
802
803 if (bfd_link_add_symbols (entry->the_bfd, &link_info) == false)
804 einfo ("%F%B: could not read symbols: %E\n", entry->the_bfd);
805
806 entry->loaded = true;
807 }
808
809 static void
810 wild (s, section, file, target, output)
811 lang_wild_statement_type * s;
812 CONST char *section;
813 CONST char *file;
814 CONST char *target;
815 lang_output_section_statement_type * output;
816 {
817 lang_input_statement_type *f;
818
819 if (file == (char *) NULL)
820 {
821 /* Perform the iteration over all files in the list */
822 for (f = (lang_input_statement_type *) file_chain.head;
823 f != (lang_input_statement_type *) NULL;
824 f = (lang_input_statement_type *) f->next)
825 {
826 wild_section (s, section, f, output);
827 }
828 }
829 else
830 {
831 /* Perform the iteration over a single file */
832 wild_section (s, section, lookup_name (file), output);
833 }
834 if (section != (char *) NULL
835 && strcmp (section, "COMMON") == 0
836 && default_common_section == (lang_output_section_statement_type *) NULL)
837 {
838 /* Remember the section that common is going to incase we later
839 get something which doesn't know where to put it */
840 default_common_section = output;
841 }
842 }
843
844 /*
845 read in all the files
846 */
847
848 static bfd *
849 open_output (name)
850 CONST char *name;
851 {
852 bfd *output;
853
854 if (output_target == (char *) NULL)
855 {
856 if (current_target != (char *) NULL)
857 output_target = current_target;
858 else
859 output_target = default_target;
860 }
861 output = bfd_openw (name, output_target);
862
863 if (output == (bfd *) NULL)
864 {
865 if (bfd_get_error () == bfd_error_invalid_target)
866 {
867 einfo ("%P%F: target %s not found\n", output_target);
868 }
869 einfo ("%P%F: cannot open output file %s: %E\n", name);
870 }
871
872 delete_output_file_on_failure = 1;
873
874 /* output->flags |= D_PAGED;*/
875
876 if (! bfd_set_format (output, bfd_object))
877 einfo ("%P%F:%s: can not make object file: %E\n", name);
878 if (! bfd_set_arch_mach (output,
879 ldfile_output_architecture,
880 ldfile_output_machine))
881 einfo ("%P%F:%s: can not set architecture: %E\n", name);
882
883 link_info.hash = bfd_link_hash_table_create (output);
884 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
885 einfo ("%P%F: can not create link hash table: %E\n");
886
887 bfd_set_gp_size (output, g_switch_value);
888 return output;
889 }
890
891
892
893
894 static void
895 ldlang_open_output (statement)
896 lang_statement_union_type * statement;
897 {
898 switch (statement->header.type)
899 {
900 case lang_output_statement_enum:
901 ASSERT (output_bfd == (bfd *) NULL);
902 output_bfd = open_output (statement->output_statement.name);
903 ldemul_set_output_arch ();
904 if (config.magic_demand_paged && !link_info.relocateable)
905 output_bfd->flags |= D_PAGED;
906 else
907 output_bfd->flags &= ~D_PAGED;
908 if (config.text_read_only)
909 output_bfd->flags |= WP_TEXT;
910 else
911 output_bfd->flags &= ~WP_TEXT;
912 break;
913
914 case lang_target_statement_enum:
915 current_target = statement->target_statement.target;
916 break;
917 default:
918 break;
919 }
920 }
921
922 static void
923 open_input_bfds (statement)
924 lang_statement_union_type * statement;
925 {
926 switch (statement->header.type)
927 {
928 case lang_target_statement_enum:
929 current_target = statement->target_statement.target;
930 break;
931 case lang_wild_statement_enum:
932 /* Maybe we should load the file's symbols */
933 if (statement->wild_statement.filename)
934 {
935 (void) lookup_name (statement->wild_statement.filename);
936 }
937 break;
938 case lang_input_statement_enum:
939 if (statement->input_statement.real == true)
940 {
941 statement->input_statement.target = current_target;
942 load_symbols (&statement->input_statement);
943 }
944 break;
945 default:
946 break;
947 }
948 }
949
950 /* If there are [COMMONS] statements, put a wild one into the bss section */
951
952 static void
953 lang_reasonable_defaults ()
954 {
955 #if 0
956 lang_output_section_statement_lookup (".text");
957 lang_output_section_statement_lookup (".data");
958
959 default_common_section =
960 lang_output_section_statement_lookup (".bss");
961
962
963 if (placed_commons == false)
964 {
965 lang_wild_statement_type *new =
966 new_stat (lang_wild_statement,
967 &default_common_section->children);
968
969 new->section_name = "COMMON";
970 new->filename = (char *) NULL;
971 lang_list_init (&new->children);
972 }
973 #endif
974
975 }
976
977 /*
978 Add the supplied name to the symbol table as an undefined reference.
979 Remove items from the chain as we open input bfds
980 */
981 typedef struct ldlang_undef_chain_list
982 {
983 struct ldlang_undef_chain_list *next;
984 char *name;
985 } ldlang_undef_chain_list_type;
986
987 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
988
989 void
990 ldlang_add_undef (name)
991 CONST char *CONST name;
992 {
993 ldlang_undef_chain_list_type *new =
994 (ldlang_undef_chain_list_type
995 *) stat_alloc ((bfd_size_type) (sizeof (ldlang_undef_chain_list_type)));
996
997 new->next = ldlang_undef_chain_list_head;
998 ldlang_undef_chain_list_head = new;
999
1000 new->name = buystring (name);
1001 }
1002
1003 /* Run through the list of undefineds created above and place them
1004 into the linker hash table as undefined symbols belonging to the
1005 script file.
1006 */
1007 static void
1008 lang_place_undefineds ()
1009 {
1010 ldlang_undef_chain_list_type *ptr;
1011
1012 for (ptr = ldlang_undef_chain_list_head;
1013 ptr != (ldlang_undef_chain_list_type *) NULL;
1014 ptr = ptr->next)
1015 {
1016 struct bfd_link_hash_entry *h;
1017
1018 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
1019 if (h == (struct bfd_link_hash_entry *) NULL)
1020 einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1021 if (h->type == bfd_link_hash_new)
1022 {
1023 h->type = bfd_link_hash_undefined;
1024 h->u.undef.abfd = NULL;
1025 bfd_link_add_undef (link_info.hash, h);
1026 }
1027 }
1028 }
1029
1030 /* Open input files and attatch to output sections */
1031 static void
1032 map_input_to_output_sections (s, target, output_section_statement)
1033 lang_statement_union_type * s;
1034 CONST char *target;
1035 lang_output_section_statement_type * output_section_statement;
1036 {
1037 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1038 {
1039 switch (s->header.type)
1040 {
1041
1042
1043 case lang_wild_statement_enum:
1044 wild (&s->wild_statement, s->wild_statement.section_name,
1045 s->wild_statement.filename, target,
1046 output_section_statement);
1047
1048 break;
1049 case lang_constructors_statement_enum:
1050 map_input_to_output_sections (constructor_list.head,
1051 target,
1052 output_section_statement);
1053 break;
1054 case lang_output_section_statement_enum:
1055 map_input_to_output_sections (s->output_section_statement.children.head,
1056 target,
1057 &s->output_section_statement);
1058 break;
1059 case lang_output_statement_enum:
1060 break;
1061 case lang_target_statement_enum:
1062 target = s->target_statement.target;
1063 break;
1064 case lang_fill_statement_enum:
1065 case lang_input_section_enum:
1066 case lang_object_symbols_statement_enum:
1067 case lang_data_statement_enum:
1068 case lang_reloc_statement_enum:
1069 case lang_assignment_statement_enum:
1070 case lang_padding_statement_enum:
1071 case lang_input_statement_enum:
1072 if (output_section_statement != NULL
1073 && output_section_statement->bfd_section == NULL)
1074 init_os (output_section_statement);
1075 break;
1076 case lang_afile_asection_pair_statement_enum:
1077 FAIL ();
1078 break;
1079 case lang_address_statement_enum:
1080 /* Mark the specified section with the supplied address */
1081 {
1082 lang_output_section_statement_type *os =
1083 lang_output_section_statement_lookup
1084 (s->address_statement.section_name);
1085
1086 os->addr_tree = s->address_statement.address;
1087 if (os->bfd_section == (asection *) NULL)
1088 {
1089 einfo ("%P%F: cannot set the address of undefined section %s\n",
1090 s->address_statement.section_name);
1091 }
1092 }
1093 break;
1094 }
1095 }
1096 }
1097
1098 static void
1099 print_output_section_statement (output_section_statement)
1100 lang_output_section_statement_type * output_section_statement;
1101 {
1102 asection *section = output_section_statement->bfd_section;
1103
1104 print_nl ();
1105 print_section (output_section_statement->name);
1106
1107
1108 if (section)
1109 {
1110 print_dot = section->vma;
1111 print_space ();
1112 print_section ("");
1113 print_space ();
1114 print_address (section->vma);
1115 print_space ();
1116 print_size (section->_raw_size);
1117 print_space();
1118 print_size(section->_cooked_size);
1119 print_space ();
1120 print_alignment (section->alignment_power);
1121 print_space ();
1122 #if 0
1123 fprintf (config.map_file, "%s flags", output_section_statement->region->name);
1124 print_flags (stdout, &output_section_statement->flags);
1125 #endif
1126 if (section->flags & SEC_LOAD)
1127 fprintf (config.map_file, "load ");
1128 if (section->flags & SEC_ALLOC)
1129 fprintf (config.map_file, "alloc ");
1130 if (section->flags & SEC_RELOC)
1131 fprintf (config.map_file, "reloc ");
1132 if (section->flags & SEC_HAS_CONTENTS)
1133 fprintf (config.map_file, "contents ");
1134
1135 }
1136 else
1137 {
1138 fprintf (config.map_file, " (no attached output section)");
1139 }
1140 print_nl ();
1141 if (output_section_statement->load_base)
1142 {
1143 int b = exp_get_value_int(output_section_statement->load_base,
1144 0, "output base", lang_final_phase_enum);
1145 printf("Output address %08x\n", b);
1146 }
1147 if (output_section_statement->section_alignment >= 0
1148 || output_section_statement->section_alignment >= 0)
1149 {
1150 printf("\t\t\t\t\tforced alignment ");
1151 if ( output_section_statement->section_alignment >= 0)
1152 {
1153 printf("section 2**%d ",output_section_statement->section_alignment );
1154 }
1155 if ( output_section_statement->subsection_alignment >= 0)
1156 {
1157 printf("subsection 2**%d ",output_section_statement->subsection_alignment );
1158 }
1159
1160 print_nl ();
1161 }
1162 print_statement (output_section_statement->children.head,
1163 output_section_statement);
1164
1165 }
1166
1167 static void
1168 print_assignment (assignment, output_section)
1169 lang_assignment_statement_type * assignment;
1170 lang_output_section_statement_type * output_section;
1171 {
1172 etree_value_type result;
1173
1174 print_section ("");
1175 print_space ();
1176 print_section ("");
1177 print_space ();
1178 print_address (print_dot);
1179 print_space ();
1180 result = exp_fold_tree (assignment->exp->assign.src,
1181 output_section,
1182 lang_final_phase_enum,
1183 print_dot,
1184 &print_dot);
1185
1186 if (result.valid)
1187 {
1188 print_address (result.value);
1189 }
1190 else
1191 {
1192 fprintf (config.map_file, "*undefined*");
1193 }
1194 print_space ();
1195 exp_print_tree (assignment->exp);
1196
1197 fprintf (config.map_file, "\n");
1198 }
1199
1200 static void
1201 print_input_statement (statm)
1202 lang_input_statement_type * statm;
1203 {
1204 if (statm->filename != (char *) NULL)
1205 {
1206 fprintf (config.map_file, "LOAD %s\n", statm->filename);
1207 }
1208 }
1209
1210 /* Print all the defined symbols for the abfd provided by in the supplied
1211 section.
1212 */
1213
1214 static boolean
1215 print_one_symbol (hash_entry, ptr)
1216 struct bfd_link_hash_entry *hash_entry;
1217 PTR ptr;
1218 {
1219 asection * sec = (asection *)ptr;
1220
1221 if (hash_entry->type == bfd_link_hash_defined)
1222 {
1223 if (sec == hash_entry->u.def.section) {
1224 print_section ("");
1225 fprintf (config.map_file, " ");
1226 print_section ("");
1227 fprintf (config.map_file, " ");
1228 print_address (hash_entry->u.def.value + outside_section_address (sec));
1229 fprintf (config.map_file, " %s", hash_entry->root.string);
1230 print_nl ();
1231 }
1232 }
1233
1234 return true;
1235 }
1236
1237 static void
1238 print_input_section (in)
1239 lang_input_section_type * in;
1240 {
1241 asection *i = in->section;
1242 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
1243
1244 if (size != 0)
1245 {
1246 print_section ("");
1247 fprintf (config.map_file, " ");
1248 print_section (i->name);
1249 fprintf (config.map_file, " ");
1250 if (i->output_section)
1251 {
1252 print_address (i->output_section->vma + i->output_offset);
1253 fprintf (config.map_file, " ");
1254 print_size (i->_raw_size);
1255 fprintf (config.map_file, " ");
1256 print_size(i->_cooked_size);
1257 fprintf (config.map_file, " ");
1258 print_alignment (i->alignment_power);
1259 fprintf (config.map_file, " ");
1260 if (in->ifile)
1261 {
1262
1263 bfd *abfd = in->ifile->the_bfd;
1264
1265 if (in->ifile->just_syms_flag == true)
1266 {
1267 fprintf (config.map_file, "symbols only ");
1268 }
1269
1270 fprintf (config.map_file, " %s ", abfd->xvec->name);
1271 if (abfd->my_archive != (bfd *) NULL)
1272 {
1273 fprintf (config.map_file, "[%s]%s", abfd->my_archive->filename,
1274 abfd->filename);
1275 }
1276 else
1277 {
1278 fprintf (config.map_file, "%s", abfd->filename);
1279 }
1280 fprintf (config.map_file, "(overhead %d bytes)", (int) bfd_alloc_size (abfd));
1281 print_nl ();
1282
1283 /* Print all the symbols */
1284 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
1285 }
1286 else
1287 {
1288 print_nl ();
1289 }
1290
1291
1292 print_dot = outside_section_address (i) + size;
1293 }
1294 else
1295 {
1296 fprintf (config.map_file, "No output section allocated\n");
1297 }
1298 }
1299 }
1300
1301 static void
1302 print_fill_statement (fill)
1303 lang_fill_statement_type * fill;
1304 {
1305 fprintf (config.map_file, "FILL mask ");
1306 print_fill (fill->fill);
1307 }
1308
1309 static void
1310 print_data_statement (data)
1311 lang_data_statement_type * data;
1312 {
1313 /* bfd_vma value; */
1314 print_section ("");
1315 print_space ();
1316 print_section ("");
1317 print_space ();
1318 /* ASSERT(print_dot == data->output_vma);*/
1319
1320 print_address (data->output_vma + data->output_section->vma);
1321 print_space ();
1322 print_address (data->value);
1323 print_space ();
1324 switch (data->type)
1325 {
1326 case BYTE:
1327 fprintf (config.map_file, "BYTE ");
1328 print_dot += BYTE_SIZE;
1329 break;
1330 case SHORT:
1331 fprintf (config.map_file, "SHORT ");
1332 print_dot += SHORT_SIZE;
1333 break;
1334 case LONG:
1335 fprintf (config.map_file, "LONG ");
1336 print_dot += LONG_SIZE;
1337 break;
1338 case QUAD:
1339 fprintf (config.map_file, "QUAD ");
1340 print_dot += QUAD_SIZE;
1341 break;
1342 }
1343
1344 exp_print_tree (data->exp);
1345
1346 fprintf (config.map_file, "\n");
1347 }
1348
1349 /* Print a reloc statement. */
1350
1351 static void
1352 print_reloc_statement (reloc)
1353 lang_reloc_statement_type *reloc;
1354 {
1355 print_section ("");
1356 print_space ();
1357 print_section ("");
1358 print_space ();
1359
1360 /* ASSERT(print_dot == data->output_vma);*/
1361
1362 print_address (reloc->output_vma + reloc->output_section->vma);
1363 print_space ();
1364 print_address (reloc->addend_value);
1365 print_space ();
1366
1367 fprintf (config.map_file, "RELOC %s ", reloc->howto->name);
1368
1369 print_dot += bfd_get_reloc_size (reloc->howto);
1370
1371 exp_print_tree (reloc->addend_exp);
1372
1373 fprintf (config.map_file, "\n");
1374 }
1375
1376 static void
1377 print_padding_statement (s)
1378 lang_padding_statement_type * s;
1379 {
1380 print_section ("");
1381 print_space ();
1382 print_section ("*fill*");
1383 print_space ();
1384 print_address (s->output_offset + s->output_section->vma);
1385 print_space ();
1386 print_size (s->size);
1387 print_space ();
1388 print_fill (s->fill);
1389 print_nl ();
1390
1391 print_dot = s->output_offset + s->output_section->vma + s->size;
1392
1393 }
1394
1395 static void
1396 print_wild_statement (w, os)
1397 lang_wild_statement_type * w;
1398 lang_output_section_statement_type * os;
1399 {
1400 fprintf (config.map_file, " from ");
1401 if (w->filename != (char *) NULL)
1402 {
1403 fprintf (config.map_file, "%s", w->filename);
1404 }
1405 else
1406 {
1407 fprintf (config.map_file, "*");
1408 }
1409 if (w->section_name != (char *) NULL)
1410 {
1411 fprintf (config.map_file, "(%s)", w->section_name);
1412 }
1413 else
1414 {
1415 fprintf (config.map_file, "(*)");
1416 }
1417 print_nl ();
1418 print_statement (w->children.head, os);
1419
1420 }
1421 static void
1422 print_statement (s, os)
1423 lang_statement_union_type * s;
1424 lang_output_section_statement_type * os;
1425 {
1426 while (s)
1427 {
1428 switch (s->header.type)
1429 {
1430 case lang_constructors_statement_enum:
1431 fprintf (config.map_file, "constructors:\n");
1432 print_statement (constructor_list.head, os);
1433 break;
1434 case lang_wild_statement_enum:
1435 print_wild_statement (&s->wild_statement, os);
1436 break;
1437 default:
1438 fprintf (config.map_file, "Fail with %d\n", s->header.type);
1439 FAIL ();
1440 break;
1441 case lang_address_statement_enum:
1442 fprintf (config.map_file, "address\n");
1443 break;
1444 case lang_object_symbols_statement_enum:
1445 fprintf (config.map_file, "object symbols\n");
1446 break;
1447 case lang_fill_statement_enum:
1448 print_fill_statement (&s->fill_statement);
1449 break;
1450 case lang_data_statement_enum:
1451 print_data_statement (&s->data_statement);
1452 break;
1453 case lang_reloc_statement_enum:
1454 print_reloc_statement (&s->reloc_statement);
1455 break;
1456 case lang_input_section_enum:
1457 print_input_section (&s->input_section);
1458 break;
1459 case lang_padding_statement_enum:
1460 print_padding_statement (&s->padding_statement);
1461 break;
1462 case lang_output_section_statement_enum:
1463 print_output_section_statement (&s->output_section_statement);
1464 break;
1465 case lang_assignment_statement_enum:
1466 print_assignment (&s->assignment_statement,
1467 os);
1468 break;
1469 case lang_target_statement_enum:
1470 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
1471 break;
1472 case lang_output_statement_enum:
1473 fprintf (config.map_file, "OUTPUT(%s %s)\n",
1474 s->output_statement.name,
1475 output_target ? output_target : "");
1476 break;
1477 case lang_input_statement_enum:
1478 print_input_statement (&s->input_statement);
1479 break;
1480 case lang_afile_asection_pair_statement_enum:
1481 FAIL ();
1482 break;
1483 }
1484 s = s->next;
1485 }
1486 }
1487
1488
1489 static void
1490 print_statements ()
1491 {
1492 print_statement (statement_list.head,
1493 abs_output_section);
1494
1495 }
1496
1497 static bfd_vma
1498 insert_pad (this_ptr, fill, power, output_section_statement, dot)
1499 lang_statement_union_type ** this_ptr;
1500 fill_type fill;
1501 unsigned int power;
1502 asection * output_section_statement;
1503 bfd_vma dot;
1504 {
1505 /* Align this section first to the
1506 input sections requirement, then
1507 to the output section's requirement.
1508 If this alignment is > than any seen before,
1509 then record it too. Perform the alignment by
1510 inserting a magic 'padding' statement.
1511 */
1512
1513 unsigned int alignment_needed = align_power (dot, power) - dot;
1514
1515 if (alignment_needed != 0)
1516 {
1517 lang_statement_union_type *new =
1518 (lang_statement_union_type *)
1519 stat_alloc ((bfd_size_type) (sizeof (lang_padding_statement_type)));
1520
1521 /* Link into existing chain */
1522 new->header.next = *this_ptr;
1523 *this_ptr = new;
1524 new->header.type = lang_padding_statement_enum;
1525 new->padding_statement.output_section = output_section_statement;
1526 new->padding_statement.output_offset =
1527 dot - output_section_statement->vma;
1528 new->padding_statement.fill = fill;
1529 new->padding_statement.size = alignment_needed;
1530 }
1531
1532
1533 /* Remember the most restrictive alignment */
1534 if (power > output_section_statement->alignment_power)
1535 {
1536 output_section_statement->alignment_power = power;
1537 }
1538 output_section_statement->_raw_size += alignment_needed;
1539 return alignment_needed + dot;
1540
1541 }
1542
1543 /* Work out how much this section will move the dot point */
1544 static bfd_vma
1545 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
1546 lang_statement_union_type ** this_ptr;
1547 lang_output_section_statement_type * output_section_statement;
1548 fill_type fill;
1549 bfd_vma dot;
1550 boolean relax;
1551 {
1552 lang_input_section_type *is = &((*this_ptr)->input_section);
1553 asection *i = is->section;
1554
1555 if (is->ifile->just_syms_flag == false)
1556 {
1557 if (output_section_statement->subsection_alignment != -1)
1558 i->alignment_power =
1559 output_section_statement->subsection_alignment;
1560
1561 dot = insert_pad (this_ptr, fill, i->alignment_power,
1562 output_section_statement->bfd_section, dot);
1563
1564 /* Remember where in the output section this input section goes */
1565
1566 i->output_offset = dot - output_section_statement->bfd_section->vma;
1567
1568 /* Mark how big the output section must be to contain this now
1569 */
1570 if (i->_cooked_size != 0)
1571 dot += i->_cooked_size;
1572 else
1573 dot += i->_raw_size;
1574 output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
1575 }
1576 else
1577 {
1578 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
1579 }
1580
1581 return dot;
1582 }
1583
1584 /* This variable indicates whether bfd_relax_section should be called
1585 again. */
1586
1587 static boolean relax_again;
1588
1589 /* Set the sizes for all the output sections. */
1590
1591 bfd_vma
1592 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
1593 lang_statement_union_type * s;
1594 lang_output_section_statement_type * output_section_statement;
1595 lang_statement_union_type ** prev;
1596 fill_type fill;
1597 bfd_vma dot;
1598 boolean relax;
1599 {
1600 /* Size up the sections from their constituent parts */
1601 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1602 {
1603 switch (s->header.type)
1604 {
1605
1606 case lang_output_section_statement_enum:
1607 {
1608 bfd_vma after;
1609 lang_output_section_statement_type *os = &s->output_section_statement;
1610
1611 if (os->bfd_section == NULL)
1612 {
1613 /* This section was never actually created. */
1614 break;
1615 }
1616
1617 /* If this is a COFF shared library section, use the size and
1618 address from the input section. FIXME: This is COFF
1619 specific; it would be cleaner if there were some other way
1620 to do this, but nothing simple comes to mind. */
1621 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
1622 {
1623 asection *input;
1624
1625 if (os->children.head == NULL
1626 || os->children.head->next != NULL
1627 || os->children.head->header.type != lang_input_section_enum)
1628 einfo ("%P%X: Internal error on COFF shared library section %s",
1629 os->name);
1630
1631 input = os->children.head->input_section.section;
1632 bfd_set_section_vma (os->bfd_section->owner,
1633 os->bfd_section,
1634 bfd_section_vma (input->owner, input));
1635 os->bfd_section->_raw_size = input->_raw_size;
1636 break;
1637 }
1638
1639 if (os->bfd_section == &bfd_abs_section)
1640 {
1641 /* No matter what happens, an abs section starts at zero */
1642 bfd_set_section_vma (0, os->bfd_section, 0);
1643 }
1644 else
1645 {
1646 if (os->addr_tree == (etree_type *) NULL)
1647 {
1648 /* No address specified for this section, get one
1649 from the region specification
1650 */
1651 if (os->region == (lang_memory_region_type *) NULL)
1652 {
1653 os->region = lang_memory_region_lookup ("*default*");
1654 }
1655 dot = os->region->current;
1656 if (os->section_alignment == -1)
1657 dot = align_power (dot, os->bfd_section->alignment_power);
1658 }
1659 else
1660 {
1661 etree_value_type r;
1662
1663 r = exp_fold_tree (os->addr_tree,
1664 abs_output_section,
1665 lang_allocating_phase_enum,
1666 dot, &dot);
1667 if (r.valid == false)
1668 {
1669 einfo ("%F%S: non constant address expression for section %s\n",
1670 os->name);
1671 }
1672 dot = r.value;
1673 }
1674 /* The section starts here */
1675 /* First, align to what the section needs */
1676
1677 if (os->section_alignment != -1)
1678 dot = align_power (dot, os->section_alignment);
1679
1680 bfd_set_section_vma (0, os->bfd_section, dot);
1681
1682 if (os->load_base) {
1683 os->bfd_section->lma
1684 = exp_get_value_int(os->load_base, 0,"load base", lang_final_phase_enum);
1685 }
1686 }
1687
1688
1689 os->bfd_section->output_offset = 0;
1690
1691 (void) lang_size_sections (os->children.head, os, &os->children.head,
1692 os->fill, dot, relax);
1693 /* Ignore the size of the input sections, use the vma and size to */
1694 /* align against */
1695
1696 after = ALIGN_N (os->bfd_section->vma +
1697 os->bfd_section->_raw_size,
1698 /* The coercion here is important, see ld.h. */
1699 (bfd_vma) os->block_value);
1700
1701 os->bfd_section->_raw_size = after - os->bfd_section->vma;
1702 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
1703 os->processed = true;
1704
1705 /* Replace into region ? */
1706 if (os->addr_tree == (etree_type *) NULL
1707 && os->region != (lang_memory_region_type *) NULL)
1708 {
1709 os->region->current = dot;
1710 /* Make sure this isn't silly */
1711 if (( os->region->current
1712 > os->region->origin + os->region->length)
1713 || ( os->region->origin > os->region->current ))
1714 {
1715 einfo ("%X%P: region %s is full (%B section %s)\n",
1716 os->region->name,
1717 os->bfd_section->owner,
1718 os->bfd_section->name);
1719 /* Reset the region pointer */
1720 os->region->current = 0;
1721
1722 }
1723
1724 }
1725 }
1726
1727 break;
1728 case lang_constructors_statement_enum:
1729 dot = lang_size_sections (constructor_list.head,
1730 output_section_statement,
1731 &s->wild_statement.children.head,
1732 fill,
1733 dot, relax);
1734 break;
1735
1736 case lang_data_statement_enum:
1737 {
1738 unsigned int size = 0;
1739
1740 s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
1741 s->data_statement.output_section =
1742 output_section_statement->bfd_section;
1743
1744 switch (s->data_statement.type)
1745 {
1746 case QUAD:
1747 size = QUAD_SIZE;
1748 break;
1749 case LONG:
1750 size = LONG_SIZE;
1751 break;
1752 case SHORT:
1753 size = SHORT_SIZE;
1754 break;
1755 case BYTE:
1756 size = BYTE_SIZE;
1757 break;
1758
1759 }
1760 dot += size;
1761 output_section_statement->bfd_section->_raw_size += size;
1762 }
1763 break;
1764
1765 case lang_reloc_statement_enum:
1766 {
1767 int size;
1768
1769 s->reloc_statement.output_vma =
1770 dot - output_section_statement->bfd_section->vma;
1771 s->reloc_statement.output_section =
1772 output_section_statement->bfd_section;
1773 size = bfd_get_reloc_size (s->reloc_statement.howto);
1774 dot += size;
1775 output_section_statement->bfd_section->_raw_size += size;
1776 }
1777 break;
1778
1779 case lang_wild_statement_enum:
1780
1781 dot = lang_size_sections (s->wild_statement.children.head,
1782 output_section_statement,
1783 &s->wild_statement.children.head,
1784
1785 fill, dot, relax);
1786
1787 break;
1788
1789 case lang_object_symbols_statement_enum:
1790 link_info.create_object_symbols_section =
1791 output_section_statement->bfd_section;
1792 break;
1793 case lang_output_statement_enum:
1794 case lang_target_statement_enum:
1795 break;
1796 case lang_input_section_enum:
1797 {
1798 asection *i;
1799
1800 i = (*prev)->input_section.section;
1801 if (! relax)
1802 i->_cooked_size = i->_raw_size;
1803 else
1804 {
1805 boolean again;
1806
1807 if (! bfd_relax_section (i->owner, i, &link_info, &again))
1808 einfo ("%P%F: can't relax section: %E\n");
1809 if (again)
1810 relax_again = true;
1811 }
1812 dot = size_input_section (prev,
1813 output_section_statement,
1814 output_section_statement->fill,
1815 dot, relax);
1816 }
1817 break;
1818 case lang_input_statement_enum:
1819 break;
1820 case lang_fill_statement_enum:
1821 s->fill_statement.output_section = output_section_statement->bfd_section;
1822
1823 fill = s->fill_statement.fill;
1824 break;
1825 case lang_assignment_statement_enum:
1826 {
1827 bfd_vma newdot = dot;
1828
1829 exp_fold_tree (s->assignment_statement.exp,
1830 output_section_statement,
1831 lang_allocating_phase_enum,
1832 dot,
1833 &newdot);
1834
1835 if (newdot != dot && !relax)
1836 {
1837 /* The assignment changed dot. Insert a pad. */
1838 if (output_section_statement == abs_output_section)
1839 {
1840 /* If we don't have an output section, then just adjust
1841 the default memory address. */
1842 lang_memory_region_lookup ("*default*")->current = newdot;
1843 }
1844 else
1845 {
1846 lang_statement_union_type *new =
1847 ((lang_statement_union_type *)
1848 stat_alloc (sizeof (lang_padding_statement_type)));
1849
1850 /* Link into existing chain */
1851 new->header.next = *prev;
1852 *prev = new;
1853 new->header.type = lang_padding_statement_enum;
1854 new->padding_statement.output_section =
1855 output_section_statement->bfd_section;
1856 new->padding_statement.output_offset =
1857 dot - output_section_statement->bfd_section->vma;
1858 new->padding_statement.fill = fill;
1859 new->padding_statement.size = newdot - dot;
1860 output_section_statement->bfd_section->_raw_size +=
1861 new->padding_statement.size;
1862 }
1863
1864 dot = newdot;
1865 }
1866 }
1867 break;
1868
1869 case lang_padding_statement_enum:
1870 /* If we are relaxing, and this is not the first pass, some
1871 padding statements may have been inserted during previous
1872 passes. We may have to move the padding statement to a new
1873 location if dot has a different value at this point in this
1874 pass than it did at this point in the previous pass. */
1875 s->padding_statement.output_offset =
1876 dot - output_section_statement->bfd_section->vma;
1877 dot += s->padding_statement.size;
1878 break;
1879
1880 default:
1881 FAIL ();
1882 break;
1883
1884 /* This can only get here when relaxing is turned on */
1885
1886 case lang_address_statement_enum:
1887 break;
1888 }
1889 prev = &s->header.next;
1890 }
1891 return dot;
1892 }
1893
1894 static bfd_vma
1895 lang_do_assignments (s, output_section_statement, fill, dot)
1896 lang_statement_union_type * s;
1897 lang_output_section_statement_type * output_section_statement;
1898 fill_type fill;
1899 bfd_vma dot;
1900 {
1901 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1902 {
1903 switch (s->header.type)
1904 {
1905 case lang_constructors_statement_enum:
1906 dot = lang_do_assignments (constructor_list.head,
1907 output_section_statement,
1908 fill,
1909 dot);
1910 break;
1911
1912 case lang_output_section_statement_enum:
1913 {
1914 lang_output_section_statement_type *os =
1915 &(s->output_section_statement);
1916
1917 if (os->bfd_section != NULL)
1918 {
1919 dot = os->bfd_section->vma;
1920 (void) lang_do_assignments (os->children.head, os,
1921 os->fill, dot);
1922 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
1923 }
1924 }
1925 break;
1926 case lang_wild_statement_enum:
1927
1928 dot = lang_do_assignments (s->wild_statement.children.head,
1929 output_section_statement,
1930 fill, dot);
1931
1932 break;
1933
1934 case lang_object_symbols_statement_enum:
1935 case lang_output_statement_enum:
1936 case lang_target_statement_enum:
1937 #if 0
1938 case lang_common_statement_enum:
1939 #endif
1940 break;
1941 case lang_data_statement_enum:
1942 {
1943 etree_value_type value;
1944
1945 value = exp_fold_tree (s->data_statement.exp,
1946 abs_output_section,
1947 lang_final_phase_enum, dot, &dot);
1948 s->data_statement.value = value.value;
1949 if (value.valid == false)
1950 einfo ("%F%P: invalid data statement\n");
1951 }
1952 switch (s->data_statement.type)
1953 {
1954 case QUAD:
1955 dot += QUAD_SIZE;
1956 break;
1957 case LONG:
1958 dot += LONG_SIZE;
1959 break;
1960 case SHORT:
1961 dot += SHORT_SIZE;
1962 break;
1963 case BYTE:
1964 dot += BYTE_SIZE;
1965 break;
1966 }
1967 break;
1968
1969 case lang_reloc_statement_enum:
1970 {
1971 etree_value_type value;
1972
1973 value = exp_fold_tree (s->reloc_statement.addend_exp,
1974 abs_output_section,
1975 lang_final_phase_enum, dot, &dot);
1976 s->reloc_statement.addend_value = value.value;
1977 if (value.valid == false)
1978 einfo ("%F%P: invalid reloc statement\n");
1979 }
1980 dot += bfd_get_reloc_size (s->reloc_statement.howto);
1981 break;
1982
1983 case lang_input_section_enum:
1984 {
1985 asection *in = s->input_section.section;
1986
1987 if (in->_cooked_size != 0)
1988 dot += in->_cooked_size;
1989 else
1990 dot += in->_raw_size;
1991 }
1992 break;
1993
1994 case lang_input_statement_enum:
1995 break;
1996 case lang_fill_statement_enum:
1997 fill = s->fill_statement.fill;
1998 break;
1999 case lang_assignment_statement_enum:
2000 {
2001 exp_fold_tree (s->assignment_statement.exp,
2002 output_section_statement,
2003 lang_final_phase_enum,
2004 dot,
2005 &dot);
2006 }
2007
2008 break;
2009 case lang_padding_statement_enum:
2010 dot += s->padding_statement.size;
2011 break;
2012 default:
2013 FAIL ();
2014 break;
2015 case lang_address_statement_enum:
2016 break;
2017 }
2018
2019 }
2020 return dot;
2021 }
2022
2023 static void
2024 lang_finish ()
2025 {
2026 struct bfd_link_hash_entry *h;
2027 boolean warn = link_info.relocateable ? false : true;
2028
2029 if (entry_symbol == (char *) NULL)
2030 {
2031 /* No entry has been specified. Look for start, but don't warn
2032 if we don't find it. */
2033 entry_symbol = "start";
2034 warn = false;
2035 }
2036
2037 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
2038 if (h != (struct bfd_link_hash_entry *) NULL
2039 && h->type == bfd_link_hash_defined)
2040 {
2041 bfd_vma val;
2042
2043 val = (h->u.def.value
2044 + bfd_get_section_vma (output_bfd,
2045 h->u.def.section->output_section)
2046 + h->u.def.section->output_offset);
2047 if (! bfd_set_start_address (output_bfd, val))
2048 einfo ("%P%F:%s: can't set start address\n", entry_symbol);
2049 }
2050 else
2051 {
2052 asection *ts;
2053
2054 /* Can't find the entry symbol. Use the first address in the
2055 text section. */
2056 ts = bfd_get_section_by_name (output_bfd, ".text");
2057 if (ts != (asection *) NULL)
2058 {
2059 if (warn)
2060 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2061 entry_symbol, bfd_get_section_vma (output_bfd, ts));
2062 if (! bfd_set_start_address (output_bfd,
2063 bfd_get_section_vma (output_bfd, ts)))
2064 einfo ("%P%F: can't set start address\n");
2065 }
2066 else
2067 {
2068 if (warn)
2069 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2070 entry_symbol);
2071 }
2072 }
2073 }
2074
2075 /* By now we know the target architecture, and we may have an */
2076 /* ldfile_output_machine_name */
2077 static void
2078 lang_check ()
2079 {
2080 lang_statement_union_type *file;
2081 bfd *input_bfd;
2082 unsigned long input_machine;
2083 enum bfd_architecture input_architecture;
2084 CONST bfd_arch_info_type *compatible;
2085
2086 for (file = file_chain.head;
2087 file != (lang_statement_union_type *) NULL;
2088 file = file->input_statement.next)
2089 {
2090 input_bfd = file->input_statement.the_bfd;
2091
2092 input_machine = bfd_get_mach (input_bfd);
2093 input_architecture = bfd_get_arch (input_bfd);
2094
2095
2096 /* Inspect the architecture and ensure we're linking like with
2097 like */
2098
2099 compatible = bfd_arch_get_compatible (input_bfd,
2100 output_bfd);
2101
2102 if (compatible)
2103 {
2104 ldfile_output_machine = compatible->mach;
2105 ldfile_output_architecture = compatible->arch;
2106 }
2107 else
2108 {
2109
2110 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2111 bfd_printable_name (input_bfd), input_bfd,
2112 bfd_printable_name (output_bfd));
2113
2114 if (! bfd_set_arch_mach (output_bfd,
2115 input_architecture,
2116 input_machine))
2117 einfo ("%P%F:%s: can't set architecture: %E\n",
2118 bfd_get_filename (output_bfd));
2119 }
2120
2121 }
2122 }
2123
2124 /* Look through all the global common symbols and attach them to the
2125 correct section. The -sort-common command line switch may be used
2126 to roughly sort the entries by size. */
2127
2128 static void
2129 lang_common ()
2130 {
2131 if (link_info.relocateable
2132 && ! command_line.force_common_definition)
2133 return;
2134
2135 if (! config.sort_common)
2136 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
2137 else
2138 {
2139 unsigned int power;
2140
2141 for (power = 1; power <= 16; power <<= 1)
2142 bfd_link_hash_traverse (link_info.hash, lang_one_common,
2143 (PTR) &power);
2144 }
2145 }
2146
2147 /* Place one common symbol in the correct section. */
2148
2149 static boolean
2150 lang_one_common (h, info)
2151 struct bfd_link_hash_entry *h;
2152 PTR info;
2153 {
2154 unsigned int power_of_two;
2155 bfd_vma size;
2156 size_t align;
2157 asection *section;
2158
2159 if (h->type != bfd_link_hash_common)
2160 return true;
2161
2162 size = h->u.c.size;
2163 switch (size)
2164 {
2165 case 0:
2166 case 1:
2167 power_of_two = 0;
2168 align = 1;
2169 break;
2170 case 2:
2171 power_of_two = 1;
2172 align = 2;
2173 break;
2174 case 3:
2175 case 4:
2176 power_of_two = 2;
2177 align = 4;
2178 break;
2179 case 5:
2180 case 6:
2181 case 7:
2182 case 8:
2183 power_of_two = 3;
2184 align = 8;
2185 break;
2186 default:
2187 power_of_two = 4;
2188 align = 16;
2189 break;
2190 }
2191
2192 if (config.sort_common && align != *(unsigned int *) info)
2193 return true;
2194
2195 section = h->u.c.section;
2196
2197 /* Increase the size of the section. */
2198 section->_raw_size = ALIGN_N (section->_raw_size, align);
2199
2200 /* Adjust the alignment if necessary. */
2201 if (power_of_two > section->alignment_power)
2202 section->alignment_power = power_of_two;
2203
2204 /* Change the symbol from common to defined. */
2205 h->type = bfd_link_hash_defined;
2206 h->u.def.section = section;
2207 h->u.def.value = section->_raw_size;
2208
2209 /* Increase the size of the section. */
2210 section->_raw_size += size;
2211
2212 if (config.map_file != NULL)
2213 fprintf (config.map_file, "Allocating common %s: %lx at %lx %s\n",
2214 h->root.string, (unsigned long) size,
2215 (unsigned long) h->u.def.value, section->owner->filename);
2216
2217 return true;
2218 }
2219
2220 /*
2221 run through the input files and ensure that every input
2222 section has somewhere to go. If one is found without
2223 a destination then create an input request and place it
2224 into the statement tree.
2225 */
2226
2227 static void
2228 lang_place_orphans ()
2229 {
2230 lang_input_statement_type *file;
2231
2232 for (file = (lang_input_statement_type *) file_chain.head;
2233 file != (lang_input_statement_type *) NULL;
2234 file = (lang_input_statement_type *) file->next)
2235 {
2236 asection *s;
2237
2238 if (file->just_syms_flag)
2239 continue;
2240
2241 for (s = file->the_bfd->sections;
2242 s != (asection *) NULL;
2243 s = s->next)
2244 {
2245 if (s->output_section == (asection *) NULL)
2246 {
2247 /* This section of the file is not attatched, root
2248 around for a sensible place for it to go */
2249
2250 if (file->common_section == s)
2251 {
2252 /* This is a lonely common section which must
2253 have come from an archive. We attatch to the
2254 section with the wildcard */
2255 if (! link_info.relocateable
2256 && ! command_line.force_common_definition)
2257 {
2258 if (default_common_section ==
2259 (lang_output_section_statement_type *) NULL)
2260 {
2261 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2262
2263 default_common_section =
2264 lang_output_section_statement_lookup (".bss");
2265
2266 }
2267 wild_doit (&default_common_section->children, s,
2268 default_common_section, file);
2269 }
2270 }
2271 else
2272 {
2273 lang_output_section_statement_type *os =
2274 lang_output_section_statement_lookup (s->name);
2275
2276 wild_doit (&os->children, s, os, file);
2277 }
2278 }
2279 }
2280 }
2281 }
2282
2283
2284 void
2285 lang_set_flags (ptr, flags)
2286 int *ptr;
2287 CONST char *flags;
2288 {
2289 boolean state = false;
2290
2291 *ptr = 0;
2292 while (*flags)
2293 {
2294 if (*flags == '!')
2295 {
2296 state = false;
2297 flags++;
2298 }
2299 else
2300 state = true;
2301 switch (*flags)
2302 {
2303 case 'R':
2304 /* ptr->flag_read = state; */
2305 break;
2306 case 'W':
2307 /* ptr->flag_write = state; */
2308 break;
2309 case 'X':
2310 /* ptr->flag_executable= state;*/
2311 break;
2312 case 'L':
2313 case 'I':
2314 /* ptr->flag_loadable= state;*/
2315 break;
2316 default:
2317 einfo ("%P%F: invalid syntax in flags\n");
2318 break;
2319 }
2320 flags++;
2321 }
2322 }
2323
2324
2325
2326 void
2327 lang_for_each_file (func)
2328 void (*func) PARAMS ((lang_input_statement_type *));
2329 {
2330 lang_input_statement_type *f;
2331
2332 for (f = (lang_input_statement_type *) file_chain.head;
2333 f != (lang_input_statement_type *) NULL;
2334 f = (lang_input_statement_type *) f->next)
2335 {
2336 func (f);
2337 }
2338 }
2339
2340 #if 0
2341
2342 /* Not used. */
2343
2344 void
2345 lang_for_each_input_section (func)
2346 void (*func) PARAMS ((bfd * ab, asection * as));
2347 {
2348 lang_input_statement_type *f;
2349
2350 for (f = (lang_input_statement_type *) file_chain.head;
2351 f != (lang_input_statement_type *) NULL;
2352 f = (lang_input_statement_type *) f->next)
2353 {
2354 asection *s;
2355
2356 for (s = f->the_bfd->sections;
2357 s != (asection *) NULL;
2358 s = s->next)
2359 {
2360 func (f->the_bfd, s);
2361 }
2362 }
2363 }
2364
2365 #endif
2366
2367 void
2368 ldlang_add_file (entry)
2369 lang_input_statement_type * entry;
2370 {
2371 bfd **pp;
2372
2373 lang_statement_append (&file_chain,
2374 (lang_statement_union_type *) entry,
2375 &entry->next);
2376
2377 /* The BFD linker needs to have a list of all input BFDs involved in
2378 a link. */
2379 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
2380 ASSERT (entry->the_bfd != output_bfd);
2381 for (pp = &link_info.input_bfds;
2382 *pp != (bfd *) NULL;
2383 pp = &(*pp)->link_next)
2384 ;
2385 *pp = entry->the_bfd;
2386 entry->the_bfd->usrdata = (PTR) entry;
2387 bfd_set_gp_size (entry->the_bfd, g_switch_value);
2388 }
2389
2390 void
2391 lang_add_output (name, from_script)
2392 CONST char *name;
2393 int from_script;
2394 {
2395 /* Make -o on command line override OUTPUT in script. */
2396 if (had_output_filename == false || !from_script)
2397 {
2398 output_filename = name;
2399 had_output_filename = true;
2400 }
2401 }
2402
2403
2404 static lang_output_section_statement_type *current_section;
2405
2406 static int topower(x)
2407 int x;
2408 {
2409 unsigned int i = 1;
2410 int l;
2411 if (x < 0) return -1;
2412 for (l = 0; l < 32; l++)
2413 {
2414 if (i >= x) return l;
2415 i<<=1;
2416 }
2417 return 0;
2418 }
2419 void
2420 lang_enter_output_section_statement (output_section_statement_name,
2421 address_exp, flags, block_value,
2422 align, subalign, ebase)
2423 const char *output_section_statement_name;
2424 etree_type * address_exp;
2425 int flags;
2426 bfd_vma block_value;
2427 etree_type *align;
2428 etree_type *subalign;
2429 etree_type *ebase;
2430 {
2431 lang_output_section_statement_type *os;
2432
2433 current_section =
2434 os =
2435 lang_output_section_statement_lookup (output_section_statement_name);
2436
2437
2438
2439 /* Add this statement to tree */
2440 /* add_statement(lang_output_section_statement_enum,
2441 output_section_statement);*/
2442 /* Make next things chain into subchain of this */
2443
2444 if (os->addr_tree ==
2445 (etree_type *) NULL)
2446 {
2447 os->addr_tree =
2448 address_exp;
2449 }
2450 os->flags = flags;
2451 if (flags & SEC_NEVER_LOAD)
2452 os->loadable = 0;
2453 else
2454 os->loadable = 1;
2455 os->block_value = block_value ? block_value : 1;
2456 stat_ptr = &os->children;
2457
2458 os->subsection_alignment = topower(
2459 exp_get_value_int(subalign, -1,
2460 "subsection alignment",
2461 0));
2462 os->section_alignment = topower(
2463 exp_get_value_int(align, -1,
2464 "section alignment", 0));
2465
2466 os->load_base = ebase;
2467 }
2468
2469
2470 void
2471 lang_final ()
2472 {
2473 lang_output_statement_type *new =
2474 new_stat (lang_output_statement, stat_ptr);
2475
2476 new->name = output_filename;
2477 }
2478
2479 /* Reset the current counters in the regions */
2480 static void
2481 reset_memory_regions ()
2482 {
2483 lang_memory_region_type *p = lang_memory_region_list;
2484
2485 for (p = lang_memory_region_list;
2486 p != (lang_memory_region_type *) NULL;
2487 p = p->next)
2488 {
2489 p->old_length = (bfd_size_type) (p->current - p->origin);
2490 p->current = p->origin;
2491 }
2492 }
2493
2494 void
2495 lang_process ()
2496 {
2497 lang_reasonable_defaults ();
2498 current_target = default_target;
2499
2500 lang_for_each_statement (ldlang_open_output); /* Open the output file */
2501
2502 ldemul_create_output_section_statements ();
2503
2504 /* Add to the hash table all undefineds on the command line */
2505 lang_place_undefineds ();
2506
2507 /* Create a bfd for each input file */
2508 current_target = default_target;
2509 lang_for_each_statement (open_input_bfds);
2510
2511 /* Build all sets based on the information gathered from the input
2512 files. */
2513 ldctor_build_sets ();
2514
2515 /* Size up the common data */
2516 lang_common ();
2517
2518 /* Run through the contours of the script and attatch input sections
2519 to the correct output sections
2520 */
2521 map_input_to_output_sections (statement_list.head, (char *) NULL,
2522 (lang_output_section_statement_type *) NULL);
2523
2524
2525 /* Find any sections not attatched explicitly and handle them */
2526 lang_place_orphans ();
2527
2528 ldemul_before_allocation ();
2529
2530 /* Now run around and relax if we can */
2531 if (command_line.relax)
2532 {
2533 /* First time round is a trial run to get the 'worst case'
2534 addresses of the objects if there was no relaxing. */
2535 lang_size_sections (statement_list.head,
2536 abs_output_section,
2537 &(statement_list.head), 0, (bfd_vma) 0, false);
2538
2539
2540 reset_memory_regions ();
2541
2542 /* Keep relaxing until bfd_relax_section gives up. */
2543 do
2544 {
2545 relax_again = false;
2546
2547 /* Do all the assignments with our current guesses as to
2548 section sizes. */
2549 lang_do_assignments (statement_list.head,
2550 abs_output_section,
2551 (fill_type) 0, (bfd_vma) 0);
2552
2553 /* Perform another relax pass - this time we know where the
2554 globals are, so can make better guess. */
2555 lang_size_sections (statement_list.head,
2556 abs_output_section,
2557 &(statement_list.head), 0, (bfd_vma) 0, true);
2558 }
2559 while (relax_again);
2560 }
2561 else
2562 {
2563 /* Size up the sections. */
2564 lang_size_sections (statement_list.head,
2565 abs_output_section,
2566 &(statement_list.head), 0, (bfd_vma) 0, false);
2567 }
2568
2569 /* See if anything special should be done now we know how big
2570 everything is. */
2571 ldemul_after_allocation ();
2572
2573 /* Do all the assignments, now that we know the final restingplaces
2574 of all the symbols */
2575
2576 lang_do_assignments (statement_list.head,
2577 abs_output_section,
2578 (fill_type) 0, (bfd_vma) 0);
2579
2580 /* Make sure that we're not mixing architectures */
2581
2582 lang_check ();
2583
2584 /* Final stuffs */
2585
2586 ldemul_finish ();
2587 lang_finish ();
2588 }
2589
2590 /* EXPORTED TO YACC */
2591
2592 void
2593 lang_add_wild (section_name, filename)
2594 CONST char *CONST section_name;
2595 CONST char *CONST filename;
2596 {
2597 lang_wild_statement_type *new = new_stat (lang_wild_statement,
2598 stat_ptr);
2599
2600 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
2601 {
2602 placed_commons = true;
2603 }
2604 if (filename != (char *) NULL)
2605 {
2606 lang_has_input_file = true;
2607 }
2608 new->section_name = section_name;
2609 new->filename = filename;
2610 lang_list_init (&new->children);
2611 }
2612
2613 void
2614 lang_section_start (name, address)
2615 CONST char *name;
2616 etree_type * address;
2617 {
2618 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
2619
2620 ad->section_name = name;
2621 ad->address = address;
2622 }
2623
2624 void
2625 lang_add_entry (name)
2626 CONST char *name;
2627 {
2628 entry_symbol = name;
2629 }
2630
2631 void
2632 lang_add_target (name)
2633 CONST char *name;
2634 {
2635 lang_target_statement_type *new = new_stat (lang_target_statement,
2636 stat_ptr);
2637
2638 new->target = name;
2639
2640 }
2641
2642 void
2643 lang_add_map (name)
2644 CONST char *name;
2645 {
2646 while (*name)
2647 {
2648 switch (*name)
2649 {
2650 case 'F':
2651 map_option_f = true;
2652 break;
2653 }
2654 name++;
2655 }
2656 }
2657
2658 void
2659 lang_add_fill (exp)
2660 int exp;
2661 {
2662 lang_fill_statement_type *new = new_stat (lang_fill_statement,
2663 stat_ptr);
2664
2665 new->fill = exp;
2666 }
2667
2668 void
2669 lang_add_data (type, exp)
2670 int type;
2671 union etree_union *exp;
2672 {
2673
2674 lang_data_statement_type *new = new_stat (lang_data_statement,
2675 stat_ptr);
2676
2677 new->exp = exp;
2678 new->type = type;
2679
2680 }
2681
2682 /* Create a new reloc statement. RELOC is the BFD relocation type to
2683 generate. HOWTO is the corresponding howto structure (we could
2684 look this up, but the caller has already done so). SECTION is the
2685 section to generate a reloc against, or NAME is the name of the
2686 symbol to generate a reloc against. Exactly one of SECTION and
2687 NAME must be NULL. ADDEND is an expression for the addend. */
2688
2689 void
2690 lang_add_reloc (reloc, howto, section, name, addend)
2691 bfd_reloc_code_real_type reloc;
2692 const reloc_howto_type *howto;
2693 asection *section;
2694 const char *name;
2695 union etree_union *addend;
2696 {
2697 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
2698
2699 p->reloc = reloc;
2700 p->howto = howto;
2701 p->section = section;
2702 p->name = name;
2703 p->addend_exp = addend;
2704
2705 p->addend_value = 0;
2706 p->output_section = NULL;
2707 p->output_vma = 0;
2708 }
2709
2710 void
2711 lang_add_assignment (exp)
2712 etree_type * exp;
2713 {
2714 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
2715 stat_ptr);
2716
2717 new->exp = exp;
2718 }
2719
2720 void
2721 lang_add_attribute (attribute)
2722 enum statement_enum attribute;
2723 {
2724 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
2725 }
2726
2727 void
2728 lang_startup (name)
2729 CONST char *name;
2730 {
2731 if (startup_file != (char *) NULL)
2732 {
2733 einfo ("%P%Fmultiple STARTUP files\n");
2734 }
2735 first_file->filename = name;
2736 first_file->local_sym_name = name;
2737 first_file->real = true;
2738
2739 startup_file = name;
2740 }
2741
2742 void
2743 lang_float (maybe)
2744 boolean maybe;
2745 {
2746 lang_float_flag = maybe;
2747 }
2748
2749 void
2750 lang_leave_output_section_statement (fill, memspec)
2751 bfd_vma fill;
2752 CONST char *memspec;
2753 {
2754 current_section->fill = fill;
2755 current_section->region = lang_memory_region_lookup (memspec);
2756 stat_ptr = &statement_list;
2757
2758 /* We remember if we are closing a .data section, since we use it to
2759 store constructors in */
2760 if (strcmp (current_section->name, ".data") == 0)
2761 {
2762 end_of_data_section_statement_list = statement_list;
2763
2764 }
2765 }
2766
2767 /*
2768 Create an absolute symbol with the given name with the value of the
2769 address of first byte of the section named.
2770
2771 If the symbol already exists, then do nothing.
2772 */
2773 void
2774 lang_abs_symbol_at_beginning_of (secname, name)
2775 const char *secname;
2776 const char *name;
2777 {
2778 struct bfd_link_hash_entry *h;
2779
2780 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2781 if (h == (struct bfd_link_hash_entry *) NULL)
2782 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2783
2784 if (h->type == bfd_link_hash_new
2785 || h->type == bfd_link_hash_undefined)
2786 {
2787 asection *sec;
2788
2789 h->type = bfd_link_hash_defined;
2790
2791 sec = bfd_get_section_by_name (output_bfd, secname);
2792 if (sec == (asection *) NULL)
2793 h->u.def.value = 0;
2794 else
2795 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
2796
2797 h->u.def.section = &bfd_abs_section;
2798 }
2799 }
2800
2801 /*
2802 Create an absolute symbol with the given name with the value of the
2803 address of the first byte after the end of the section named.
2804
2805 If the symbol already exists, then do nothing.
2806 */
2807 void
2808 lang_abs_symbol_at_end_of (secname, name)
2809 const char *secname;
2810 const char *name;
2811 {
2812 struct bfd_link_hash_entry *h;
2813
2814 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
2815 if (h == (struct bfd_link_hash_entry *) NULL)
2816 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2817
2818 if (h->type == bfd_link_hash_new
2819 || h->type == bfd_link_hash_undefined)
2820 {
2821 asection *sec;
2822
2823 h->type = bfd_link_hash_defined;
2824
2825 sec = bfd_get_section_by_name (output_bfd, secname);
2826 if (sec == (asection *) NULL)
2827 h->u.def.value = 0;
2828 else
2829 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
2830 + bfd_section_size (output_bfd, sec));
2831
2832 h->u.def.section = &bfd_abs_section;
2833 }
2834 }
2835
2836 void
2837 lang_statement_append (list, element, field)
2838 lang_statement_list_type * list;
2839 lang_statement_union_type * element;
2840 lang_statement_union_type ** field;
2841 {
2842 *(list->tail) = element;
2843 list->tail = field;
2844 }
2845
2846 /* Set the output format type. -oformat overrides scripts. */
2847 void
2848 lang_add_output_format (format, from_script)
2849 CONST char *format;
2850 int from_script;
2851 {
2852 if (output_target == NULL || !from_script)
2853 output_target = format;
2854 }