1 /* This module handles expression trees.
2 Copyright (C) 1991-2018 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
5 This file is part of the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* This module is in charge of working out the contents of expressions.
25 It has to keep track of the relative/absness of a symbol etc. This
26 is done by keeping all values in a struct (an etree_value_type)
27 which contains a value, a section to which it is relative and a
41 #include "libiberty.h"
42 #include "safe-ctype.h"
44 static void exp_fold_tree_1 (etree_type
*);
45 static bfd_vma
align_n (bfd_vma
, bfd_vma
);
47 segment_type
*segments
;
49 struct ldexp_control expld
;
51 /* This structure records symbols for which we need to keep track of
52 definedness for use in the DEFINED () test. It is also used in
53 making absolute symbols section relative late in the link. */
55 struct definedness_hash_entry
57 struct bfd_hash_entry root
;
59 /* If this symbol was assigned from "dot" outside of an output
60 section statement, the section we'd like it relative to. */
63 /* Low bits of iteration count. Symbols with matching iteration have
64 been defined in this pass over the script. */
65 unsigned int iteration
: 8;
67 /* Symbol was defined by an object file. */
68 unsigned int by_object
: 1;
71 static struct bfd_hash_table definedness_table
;
73 /* Print the string representation of the given token. Surround it
74 with spaces if INFIX_P is TRUE. */
77 exp_print_token (token_code_type code
, int infix_p
)
104 { LOG2CEIL
, "LOG2CEIL" },
105 { ALIGN_K
, "ALIGN" },
112 { SECTIONS
, "SECTIONS" },
113 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
114 { MEMORY
, "MEMORY" },
115 { DEFINED
, "DEFINED" },
116 { TARGET_K
, "TARGET" },
117 { SEARCH_DIR
, "SEARCH_DIR" },
121 { ALIGNOF
, "ALIGNOF" },
122 { SIZEOF
, "SIZEOF" },
124 { LOADADDR
, "LOADADDR" },
125 { CONSTANT
, "CONSTANT" },
126 { ABSOLUTE
, "ABSOLUTE" },
129 { ASSERT_K
, "ASSERT" },
130 { REL
, "relocatable" },
131 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
132 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
133 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
134 { ORIGIN
, "ORIGIN" },
135 { LENGTH
, "LENGTH" },
136 { SEGMENT_START
, "SEGMENT_START" }
140 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
141 if (table
[idx
].code
== code
)
145 fputc (' ', config
.map_file
);
147 if (idx
< ARRAY_SIZE (table
))
148 fputs (table
[idx
].name
, config
.map_file
);
150 fputc (code
, config
.map_file
);
152 fprintf (config
.map_file
, "<code %d>", code
);
155 fputc (' ', config
.map_file
);
161 bfd_vma value
= expld
.result
.value
;
163 bfd_boolean round_up
= FALSE
;
168 /* If more than one bit is set in the value we will need to round up. */
169 if ((value
> 1) && (value
& 1))
176 expld
.result
.section
= NULL
;
177 expld
.result
.value
= result
;
183 if (expld
.result
.section
!= NULL
)
184 expld
.result
.value
+= expld
.result
.section
->vma
;
185 expld
.result
.section
= bfd_abs_section_ptr
;
186 expld
.rel_from_abs
= FALSE
;
190 new_abs (bfd_vma value
)
192 expld
.result
.valid_p
= TRUE
;
193 expld
.result
.section
= bfd_abs_section_ptr
;
194 expld
.result
.value
= value
;
195 expld
.result
.str
= NULL
;
199 exp_intop (bfd_vma value
)
201 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
202 new_e
->type
.node_code
= INT
;
203 new_e
->type
.filename
= ldlex_filename ();
204 new_e
->type
.lineno
= lineno
;
205 new_e
->value
.value
= value
;
206 new_e
->value
.str
= NULL
;
207 new_e
->type
.node_class
= etree_value
;
212 exp_bigintop (bfd_vma value
, char *str
)
214 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
215 new_e
->type
.node_code
= INT
;
216 new_e
->type
.filename
= ldlex_filename ();
217 new_e
->type
.lineno
= lineno
;
218 new_e
->value
.value
= value
;
219 new_e
->value
.str
= str
;
220 new_e
->type
.node_class
= etree_value
;
224 /* Build an expression representing an unnamed relocatable value. */
227 exp_relop (asection
*section
, bfd_vma value
)
229 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->rel
));
230 new_e
->type
.node_code
= REL
;
231 new_e
->type
.filename
= ldlex_filename ();
232 new_e
->type
.lineno
= lineno
;
233 new_e
->type
.node_class
= etree_rel
;
234 new_e
->rel
.section
= section
;
235 new_e
->rel
.value
= value
;
240 new_number (bfd_vma value
)
242 expld
.result
.valid_p
= TRUE
;
243 expld
.result
.value
= value
;
244 expld
.result
.str
= NULL
;
245 expld
.result
.section
= NULL
;
249 new_rel (bfd_vma value
, asection
*section
)
251 expld
.result
.valid_p
= TRUE
;
252 expld
.result
.value
= value
;
253 expld
.result
.str
= NULL
;
254 expld
.result
.section
= section
;
258 new_rel_from_abs (bfd_vma value
)
260 asection
*s
= expld
.section
;
262 expld
.rel_from_abs
= TRUE
;
263 expld
.result
.valid_p
= TRUE
;
264 expld
.result
.value
= value
- s
->vma
;
265 expld
.result
.str
= NULL
;
266 expld
.result
.section
= s
;
269 /* New-function for the definedness hash table. */
271 static struct bfd_hash_entry
*
272 definedness_newfunc (struct bfd_hash_entry
*entry
,
273 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
274 const char *name ATTRIBUTE_UNUSED
)
276 struct definedness_hash_entry
*ret
= (struct definedness_hash_entry
*) entry
;
279 ret
= (struct definedness_hash_entry
*)
280 bfd_hash_allocate (table
, sizeof (struct definedness_hash_entry
));
283 einfo (_("%F%P: bfd_hash_allocate failed creating symbol %s\n"), name
);
290 /* Called during processing of linker script script expressions.
291 For symbols assigned in a linker script, return a struct describing
292 where the symbol is defined relative to the current expression,
293 otherwise return NULL. */
295 static struct definedness_hash_entry
*
296 symbol_defined (const char *name
)
298 return ((struct definedness_hash_entry
*)
299 bfd_hash_lookup (&definedness_table
, name
, FALSE
, FALSE
));
302 /* Update the definedness state of NAME. Return FALSE if script symbol
303 is multiply defining a strong symbol in an object. */
306 update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
309 struct definedness_hash_entry
*defentry
310 = (struct definedness_hash_entry
*)
311 bfd_hash_lookup (&definedness_table
, name
, TRUE
, FALSE
);
313 if (defentry
== NULL
)
314 einfo (_("%F%P: bfd_hash_lookup failed creating symbol %s\n"), name
);
316 /* If the symbol was already defined, and not by a script, then it
317 must be defined by an object file or by the linker target code. */
320 && (h
->type
== bfd_link_hash_defined
321 || h
->type
== bfd_link_hash_defweak
322 || h
->type
== bfd_link_hash_common
))
324 defentry
->by_object
= 1;
325 if (h
->type
== bfd_link_hash_defined
326 && h
->u
.def
.section
->output_section
!= NULL
331 defentry
->iteration
= lang_statement_iteration
;
332 defentry
->final_sec
= bfd_abs_section_ptr
;
333 if (expld
.phase
== lang_final_phase_enum
334 && expld
.rel_from_abs
335 && expld
.result
.section
== bfd_abs_section_ptr
)
336 defentry
->final_sec
= section_for_dot ();
341 fold_segment_end (seg_align_type
*seg
)
343 if (expld
.phase
== lang_first_phase_enum
344 || expld
.section
!= bfd_abs_section_ptr
)
346 expld
.result
.valid_p
= FALSE
;
348 else if (seg
->phase
== exp_seg_align_seen
349 || seg
->phase
== exp_seg_relro_seen
)
351 seg
->phase
= exp_seg_end_seen
;
352 seg
->end
= expld
.result
.value
;
354 else if (seg
->phase
== exp_seg_done
355 || seg
->phase
== exp_seg_adjust
356 || seg
->phase
== exp_seg_relro_adjust
)
361 expld
.result
.valid_p
= FALSE
;
365 fold_unary (etree_type
*tree
)
367 exp_fold_tree_1 (tree
->unary
.child
);
368 if (expld
.result
.valid_p
)
370 switch (tree
->type
.node_code
)
373 if (expld
.phase
!= lang_first_phase_enum
)
374 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
376 expld
.result
.valid_p
= FALSE
;
388 expld
.result
.value
= ~expld
.result
.value
;
392 expld
.result
.value
= !expld
.result
.value
;
396 expld
.result
.value
= -expld
.result
.value
;
400 /* Return next place aligned to value. */
401 if (expld
.phase
!= lang_first_phase_enum
)
404 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
407 expld
.result
.valid_p
= FALSE
;
410 case DATA_SEGMENT_END
:
411 fold_segment_end (&expld
.dataseg
);
421 /* Arithmetic operators, bitwise AND, bitwise OR and XOR keep the
422 section of one of their operands only when the other operand is a
423 plain number. Losing the section when operating on two symbols,
424 ie. a result of a plain number, is required for subtraction and
425 XOR. It's justifiable for the other operations on the grounds that
426 adding, multiplying etc. two section relative values does not
427 really make sense unless they are just treated as numbers.
428 The same argument could be made for many expressions involving one
429 symbol and a number. For example, "1 << x" and "100 / x" probably
430 should not be given the section of x. The trouble is that if we
431 fuss about such things the rules become complex and it is onerous
432 to document ld expression evaluation. */
434 arith_result_section (const etree_value_type
*lhs
)
436 if (expld
.result
.section
== lhs
->section
)
438 if (expld
.section
== bfd_abs_section_ptr
439 && !config
.sane_expr
)
440 /* Duplicate the insanity in exp_fold_tree_1 case etree_value. */
441 expld
.result
.section
= bfd_abs_section_ptr
;
443 expld
.result
.section
= NULL
;
448 fold_segment_align (seg_align_type
*seg
, etree_value_type
*lhs
)
450 seg
->relro
= exp_seg_relro_start
;
451 if (expld
.phase
== lang_first_phase_enum
452 || expld
.section
!= bfd_abs_section_ptr
)
453 expld
.result
.valid_p
= FALSE
;
456 bfd_vma maxpage
= lhs
->value
;
457 bfd_vma commonpage
= expld
.result
.value
;
459 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
460 if (seg
->phase
== exp_seg_relro_adjust
)
461 expld
.result
.value
= seg
->base
;
462 else if (seg
->phase
== exp_seg_adjust
)
464 if (commonpage
< maxpage
)
465 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
466 & (maxpage
- commonpage
));
470 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
471 if (seg
->phase
== exp_seg_done
)
475 else if (seg
->phase
== exp_seg_none
)
477 seg
->phase
= exp_seg_align_seen
;
478 seg
->base
= expld
.result
.value
;
479 seg
->pagesize
= commonpage
;
480 seg
->maxpagesize
= maxpage
;
484 expld
.result
.valid_p
= FALSE
;
490 fold_segment_relro_end (seg_align_type
*seg
, etree_value_type
*lhs
)
492 /* Operands swapped! XXX_SEGMENT_RELRO_END(offset,exp) has offset
493 in expld.result and exp in lhs. */
494 seg
->relro
= exp_seg_relro_end
;
495 seg
->relro_offset
= expld
.result
.value
;
496 if (expld
.phase
== lang_first_phase_enum
497 || expld
.section
!= bfd_abs_section_ptr
)
498 expld
.result
.valid_p
= FALSE
;
499 else if (seg
->phase
== exp_seg_align_seen
500 || seg
->phase
== exp_seg_adjust
501 || seg
->phase
== exp_seg_relro_adjust
502 || seg
->phase
== exp_seg_done
)
504 if (seg
->phase
== exp_seg_align_seen
505 || seg
->phase
== exp_seg_relro_adjust
)
506 seg
->relro_end
= lhs
->value
+ expld
.result
.value
;
508 if (seg
->phase
== exp_seg_relro_adjust
509 && (seg
->relro_end
& (seg
->pagesize
- 1)))
511 seg
->relro_end
+= seg
->pagesize
- 1;
512 seg
->relro_end
&= ~(seg
->pagesize
- 1);
513 expld
.result
.value
= seg
->relro_end
- expld
.result
.value
;
516 expld
.result
.value
= lhs
->value
;
518 if (seg
->phase
== exp_seg_align_seen
)
519 seg
->phase
= exp_seg_relro_seen
;
522 expld
.result
.valid_p
= FALSE
;
526 fold_binary (etree_type
*tree
)
528 etree_value_type lhs
;
529 exp_fold_tree_1 (tree
->binary
.lhs
);
531 /* The SEGMENT_START operator is special because its first
532 operand is a string, not the name of a symbol. Note that the
533 operands have been swapped, so binary.lhs is second (default)
534 operand, binary.rhs is first operand. */
535 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
537 bfd_vma value
= expld
.result
.value
;
538 const char *segment_name
;
541 /* Check to see if the user has overridden the default
543 segment_name
= tree
->binary
.rhs
->name
.name
;
544 for (seg
= segments
; seg
; seg
= seg
->next
)
545 if (strcmp (seg
->name
, segment_name
) == 0)
548 && config
.magic_demand_paged
549 && config
.maxpagesize
!= 0
550 && (seg
->value
% config
.maxpagesize
) != 0)
551 einfo (_("%P: warning: address of `%s' "
552 "isn't multiple of maximum page size\n"),
558 new_rel_from_abs (value
);
563 exp_fold_tree_1 (tree
->binary
.rhs
);
564 expld
.result
.valid_p
&= lhs
.valid_p
;
566 if (expld
.result
.valid_p
)
568 if (lhs
.section
!= expld
.result
.section
)
570 /* If the values are from different sections, and neither is
571 just a number, make both the source arguments absolute. */
572 if (expld
.result
.section
!= NULL
573 && lhs
.section
!= NULL
)
576 lhs
.value
+= lhs
.section
->vma
;
577 lhs
.section
= bfd_abs_section_ptr
;
580 /* If the rhs is just a number, keep the lhs section. */
581 else if (expld
.result
.section
== NULL
)
583 expld
.result
.section
= lhs
.section
;
584 /* Make this NULL so that we know one of the operands
585 was just a number, for later tests. */
589 /* At this point we know that both operands have the same
590 section, or at least one of them is a plain number. */
592 switch (tree
->type
.node_code
)
596 expld.result.value = lhs.value y expld.result.value; \
597 arith_result_section (&lhs); \
600 /* Comparison operators, logical AND, and logical OR always
601 return a plain number. */
604 expld.result.value = lhs.value y expld.result.value; \
605 expld.result.section = NULL; \
626 if (expld
.result
.value
!= 0)
627 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
628 % (bfd_signed_vma
) expld
.result
.value
);
629 else if (expld
.phase
!= lang_mark_phase_enum
)
630 einfo (_("%F%P:%pS %% by zero\n"), tree
->binary
.rhs
);
631 arith_result_section (&lhs
);
635 if (expld
.result
.value
!= 0)
636 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
637 / (bfd_signed_vma
) expld
.result
.value
);
638 else if (expld
.phase
!= lang_mark_phase_enum
)
639 einfo (_("%F%P:%pS / by zero\n"), tree
->binary
.rhs
);
640 arith_result_section (&lhs
);
644 if (lhs
.value
> expld
.result
.value
)
645 expld
.result
.value
= lhs
.value
;
649 if (lhs
.value
< expld
.result
.value
)
650 expld
.result
.value
= lhs
.value
;
654 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
657 case DATA_SEGMENT_ALIGN
:
658 fold_segment_align (&expld
.dataseg
, &lhs
);
661 case DATA_SEGMENT_RELRO_END
:
662 fold_segment_relro_end (&expld
.dataseg
, &lhs
);
672 fold_trinary (etree_type
*tree
)
674 struct bfd_link_hash_entry
*save
= expld
.assign_src
;
676 exp_fold_tree_1 (tree
->trinary
.cond
);
677 expld
.assign_src
= save
;
678 if (expld
.result
.valid_p
)
679 exp_fold_tree_1 (expld
.result
.value
681 : tree
->trinary
.rhs
);
685 fold_name (etree_type
*tree
)
687 struct bfd_link_hash_entry
*h
;
688 struct definedness_hash_entry
*def
;
690 memset (&expld
.result
, 0, sizeof (expld
.result
));
692 switch (tree
->type
.node_code
)
695 if (expld
.phase
!= lang_first_phase_enum
)
697 bfd_vma hdr_size
= 0;
698 /* Don't find the real header size if only marking sections;
699 The bfd function may cache incorrect data. */
700 if (expld
.phase
!= lang_mark_phase_enum
)
701 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
702 new_number (hdr_size
);
707 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
711 new_number (h
!= NULL
712 && (h
->type
== bfd_link_hash_defined
713 || h
->type
== bfd_link_hash_defweak
714 || h
->type
== bfd_link_hash_common
)
716 || (def
= symbol_defined (tree
->name
.name
)) == NULL
718 || def
->iteration
== (lang_statement_iteration
& 255)));
722 if (expld
.assign_name
!= NULL
723 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0)
725 /* Self-assignment is only allowed for absolute symbols
726 defined in a linker script. */
727 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
732 && (h
->type
== bfd_link_hash_defined
733 || h
->type
== bfd_link_hash_defweak
)
734 && h
->u
.def
.section
== bfd_abs_section_ptr
735 && (def
= symbol_defined (tree
->name
.name
)) != NULL
736 && def
->iteration
== (lang_statement_iteration
& 255)))
737 expld
.assign_name
= NULL
;
739 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
740 new_rel_from_abs (expld
.dot
);
743 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
748 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
749 else if (h
->type
== bfd_link_hash_defined
750 || h
->type
== bfd_link_hash_defweak
)
752 asection
*output_section
;
754 output_section
= h
->u
.def
.section
->output_section
;
755 if (output_section
== NULL
)
757 if (expld
.phase
<= lang_mark_phase_enum
)
758 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
760 einfo (_("%X%P:%pS: unresolvable symbol `%s'"
761 " referenced in expression\n"),
762 tree
, tree
->name
.name
);
764 else if (output_section
== bfd_abs_section_ptr
765 && (expld
.section
!= bfd_abs_section_ptr
766 || config
.sane_expr
))
767 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
769 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
772 else if (expld
.phase
== lang_final_phase_enum
773 || (expld
.phase
!= lang_mark_phase_enum
774 && expld
.assigning_to_dot
))
775 einfo (_("%F%P:%pS: undefined symbol `%s'"
776 " referenced in expression\n"),
777 tree
, tree
->name
.name
);
778 else if (h
->type
== bfd_link_hash_new
)
780 h
->type
= bfd_link_hash_undefined
;
781 h
->u
.undef
.abfd
= NULL
;
782 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
783 bfd_link_add_undef (link_info
.hash
, h
);
785 if (expld
.assign_src
== NULL
)
786 expld
.assign_src
= h
;
788 expld
.assign_src
= (struct bfd_link_hash_entry
*) - 1;
793 if (expld
.phase
!= lang_first_phase_enum
)
795 lang_output_section_statement_type
*os
;
797 os
= lang_output_section_find (tree
->name
.name
);
800 if (expld
.phase
== lang_final_phase_enum
)
801 einfo (_("%F%P:%pS: undefined section `%s'"
802 " referenced in expression\n"),
803 tree
, tree
->name
.name
);
805 else if (os
->processed_vma
)
806 new_rel (0, os
->bfd_section
);
811 if (expld
.phase
!= lang_first_phase_enum
)
813 lang_output_section_statement_type
*os
;
815 os
= lang_output_section_find (tree
->name
.name
);
818 if (expld
.phase
== lang_final_phase_enum
)
819 einfo (_("%F%P:%pS: undefined section `%s'"
820 " referenced in expression\n"),
821 tree
, tree
->name
.name
);
823 else if (os
->processed_lma
)
825 if (os
->load_base
== NULL
)
826 new_abs (os
->bfd_section
->lma
);
829 exp_fold_tree_1 (os
->load_base
);
830 if (expld
.result
.valid_p
)
839 if (expld
.phase
!= lang_first_phase_enum
)
841 lang_output_section_statement_type
*os
;
843 os
= lang_output_section_find (tree
->name
.name
);
846 if (expld
.phase
== lang_final_phase_enum
)
847 einfo (_("%F%P:%pS: undefined section `%s'"
848 " referenced in expression\n"),
849 tree
, tree
->name
.name
);
852 else if (os
->bfd_section
!= NULL
)
856 if (tree
->type
.node_code
== SIZEOF
)
857 val
= (os
->bfd_section
->size
858 / bfd_octets_per_byte (link_info
.output_bfd
));
860 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
871 if (expld
.phase
!= lang_first_phase_enum
)
873 lang_memory_region_type
*mem
;
875 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
877 new_number (mem
->length
);
879 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
880 " referenced in expression\n"),
881 tree
, tree
->name
.name
);
887 if (expld
.phase
!= lang_first_phase_enum
)
889 lang_memory_region_type
*mem
;
891 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
893 new_rel_from_abs (mem
->origin
);
895 einfo (_("%F%P:%pS: undefined MEMORY region `%s'"
896 " referenced in expression\n"),
897 tree
, tree
->name
.name
);
902 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
903 new_number (config
.maxpagesize
);
904 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
905 new_number (config
.commonpagesize
);
907 einfo (_("%F%P:%pS: unknown constant `%s' referenced in expression\n"),
908 tree
, tree
->name
.name
);
917 /* Return true if TREE is '.'. */
920 is_dot (const etree_type
*tree
)
922 return (tree
->type
.node_class
== etree_name
923 && tree
->type
.node_code
== NAME
924 && tree
->name
.name
[0] == '.'
925 && tree
->name
.name
[1] == 0);
928 /* Return true if TREE is a constant equal to VAL. */
931 is_value (const etree_type
*tree
, bfd_vma val
)
933 return (tree
->type
.node_class
== etree_value
934 && tree
->value
.value
== val
);
937 /* Return true if TREE is an absolute symbol equal to VAL defined in
941 is_sym_value (const etree_type
*tree
, bfd_vma val
)
943 struct bfd_link_hash_entry
*h
;
944 struct definedness_hash_entry
*def
;
946 return (tree
->type
.node_class
== etree_name
947 && tree
->type
.node_code
== NAME
948 && (def
= symbol_defined (tree
->name
.name
)) != NULL
949 && def
->iteration
== (lang_statement_iteration
& 255)
950 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
953 FALSE
, FALSE
, TRUE
)) != NULL
955 && h
->type
== bfd_link_hash_defined
956 && h
->u
.def
.section
== bfd_abs_section_ptr
957 && h
->u
.def
.value
== val
);
960 /* Return true if TREE is ". != 0". */
963 is_dot_ne_0 (const etree_type
*tree
)
965 return (tree
->type
.node_class
== etree_binary
966 && tree
->type
.node_code
== NE
967 && is_dot (tree
->binary
.lhs
)
968 && is_value (tree
->binary
.rhs
, 0));
971 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
972 absolute constant with value 0 defined in a linker script. */
975 is_dot_plus_0 (const etree_type
*tree
)
977 return (tree
->type
.node_class
== etree_binary
978 && tree
->type
.node_code
== '+'
979 && is_dot (tree
->binary
.lhs
)
980 && (is_value (tree
->binary
.rhs
, 0)
981 || is_sym_value (tree
->binary
.rhs
, 0)));
984 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
987 is_align_conditional (const etree_type
*tree
)
989 if (tree
->type
.node_class
== etree_unary
990 && tree
->type
.node_code
== ALIGN_K
)
992 tree
= tree
->unary
.child
;
993 return (tree
->type
.node_class
== etree_trinary
994 && is_dot_ne_0 (tree
->trinary
.cond
)
995 && is_value (tree
->trinary
.rhs
, 1));
1001 exp_fold_tree_1 (etree_type
*tree
)
1005 memset (&expld
.result
, 0, sizeof (expld
.result
));
1009 switch (tree
->type
.node_class
)
1012 if (expld
.section
== bfd_abs_section_ptr
1013 && !config
.sane_expr
)
1014 new_abs (tree
->value
.value
);
1016 new_number (tree
->value
.value
);
1017 expld
.result
.str
= tree
->value
.str
;
1021 if (expld
.phase
!= lang_first_phase_enum
)
1023 asection
*output_section
= tree
->rel
.section
->output_section
;
1024 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
1028 memset (&expld
.result
, 0, sizeof (expld
.result
));
1032 exp_fold_tree_1 (tree
->assert_s
.child
);
1033 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
1034 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1046 fold_trinary (tree
);
1051 case etree_provided
:
1052 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1054 if (tree
->type
.node_class
!= etree_assign
)
1055 einfo (_("%F%P:%pS can not PROVIDE assignment to"
1056 " location counter\n"), tree
);
1057 if (expld
.phase
!= lang_first_phase_enum
)
1059 /* Notify the folder that this is an assignment to dot. */
1060 expld
.assigning_to_dot
= TRUE
;
1061 exp_fold_tree_1 (tree
->assign
.src
);
1062 expld
.assigning_to_dot
= FALSE
;
1064 /* If we are assigning to dot inside an output section
1065 arrange to keep the section, except for certain
1066 expressions that evaluate to zero. We ignore . = 0,
1067 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1068 We can't ignore all expressions that evaluate to zero
1069 because an otherwise empty section might have padding
1070 added by an alignment expression that changes with
1071 relaxation. Such a section might have zero size
1072 before relaxation and so be stripped incorrectly. */
1073 if (expld
.phase
== lang_mark_phase_enum
1074 && expld
.section
!= bfd_abs_section_ptr
1075 && expld
.section
!= bfd_und_section_ptr
1076 && !(expld
.result
.valid_p
1077 && expld
.result
.value
== 0
1078 && (is_value (tree
->assign
.src
, 0)
1079 || is_sym_value (tree
->assign
.src
, 0)
1080 || is_dot_plus_0 (tree
->assign
.src
)
1081 || is_align_conditional (tree
->assign
.src
))))
1082 expld
.section
->flags
|= SEC_KEEP
;
1084 if (!expld
.result
.valid_p
1085 || expld
.section
== bfd_und_section_ptr
)
1087 if (expld
.phase
!= lang_mark_phase_enum
)
1088 einfo (_("%F%P:%pS invalid assignment to"
1089 " location counter\n"), tree
);
1091 else if (expld
.dotp
== NULL
)
1092 einfo (_("%F%P:%pS assignment to location counter"
1093 " invalid outside of SECTIONS\n"), tree
);
1095 /* After allocation, assignment to dot should not be
1096 done inside an output section since allocation adds a
1097 padding statement that effectively duplicates the
1099 else if (expld
.phase
<= lang_allocating_phase_enum
1100 || expld
.section
== bfd_abs_section_ptr
)
1104 nextdot
= expld
.result
.value
;
1105 if (expld
.result
.section
!= NULL
)
1106 nextdot
+= expld
.result
.section
->vma
;
1108 nextdot
+= expld
.section
->vma
;
1109 if (nextdot
< expld
.dot
1110 && expld
.section
!= bfd_abs_section_ptr
)
1111 einfo (_("%F%P:%pS cannot move location counter backwards"
1112 " (from %V to %V)\n"),
1113 tree
, expld
.dot
, nextdot
);
1116 expld
.dot
= nextdot
;
1117 *expld
.dotp
= nextdot
;
1122 memset (&expld
.result
, 0, sizeof (expld
.result
));
1126 struct bfd_link_hash_entry
*h
= NULL
;
1128 if (tree
->type
.node_class
== etree_provide
)
1130 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1131 FALSE
, FALSE
, TRUE
);
1133 || !(h
->type
== bfd_link_hash_new
1134 || h
->type
== bfd_link_hash_undefined
1135 || h
->type
== bfd_link_hash_undefweak
1138 /* Do nothing. The symbol was never referenced, or
1139 was defined in some object file. Note that
1140 undefweak symbols are defined by PROVIDE. This
1141 is to support glibc use of __rela_iplt_start and
1142 similar weak references. */
1147 expld
.assign_name
= tree
->assign
.dst
;
1148 expld
.assign_src
= NULL
;
1149 exp_fold_tree_1 (tree
->assign
.src
);
1150 /* expld.assign_name remaining equal to tree->assign.dst
1151 below indicates the evaluation of tree->assign.src did
1152 not use the value of tree->assign.dst. We don't allow
1153 self assignment until the final phase for two reasons:
1154 1) Expressions are evaluated multiple times. With
1155 relaxation, the number of times may vary.
1156 2) Section relative symbol values cannot be correctly
1157 converted to absolute values, as is required by many
1158 expressions, until final section sizing is complete. */
1159 if (expld
.phase
== lang_final_phase_enum
1160 || expld
.assign_name
!= NULL
)
1162 if (tree
->type
.node_class
== etree_provide
)
1163 tree
->type
.node_class
= etree_provided
;
1167 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1170 einfo (_("%F%P:%s: hash creation failed\n"),
1174 /* If the expression is not valid then fake a zero value. In
1175 the final phase any errors will already have been raised,
1176 in earlier phases we want to create this definition so
1177 that it can be seen by other expressions. */
1178 if (!expld
.result
.valid_p
1179 && h
->type
== bfd_link_hash_new
)
1181 expld
.result
.value
= 0;
1182 expld
.result
.section
= NULL
;
1183 expld
.result
.valid_p
= TRUE
;
1186 if (expld
.result
.valid_p
)
1188 if (expld
.result
.section
== NULL
)
1189 expld
.result
.section
= expld
.section
;
1190 if (!update_definedness (tree
->assign
.dst
, h
) && 0)
1192 /* Symbol was already defined. For now this error
1193 is disabled because it causes failures in the ld
1194 testsuite: ld-elf/var1, ld-scripts/defined5, and
1195 ld-scripts/pr14962. Some of these no doubt
1196 reflect scripts used in the wild. */
1197 (*link_info
.callbacks
->multiple_definition
)
1198 (&link_info
, h
, link_info
.output_bfd
,
1199 expld
.result
.section
, expld
.result
.value
);
1201 h
->type
= bfd_link_hash_defined
;
1202 h
->u
.def
.value
= expld
.result
.value
;
1203 h
->u
.def
.section
= expld
.result
.section
;
1204 h
->linker_def
= ! tree
->assign
.type
.lineno
;
1205 h
->ldscript_def
= 1;
1206 h
->rel_from_abs
= expld
.rel_from_abs
;
1207 if (tree
->assign
.hidden
)
1208 bfd_link_hide_symbol (link_info
.output_bfd
,
1211 /* Copy the symbol type if this is an expression only
1212 referencing a single symbol. (If the expression
1213 contains ternary conditions, ignoring symbols on
1215 if (expld
.assign_src
!= NULL
1216 && (expld
.assign_src
1217 != (struct bfd_link_hash_entry
*) -1))
1218 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
, h
,
1222 expld
.assign_name
= NULL
;
1232 memset (&expld
.result
, 0, sizeof (expld
.result
));
1238 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1240 expld
.rel_from_abs
= FALSE
;
1243 expld
.section
= current_section
;
1244 exp_fold_tree_1 (tree
);
1248 exp_fold_tree_no_dot (etree_type
*tree
)
1250 expld
.rel_from_abs
= FALSE
;
1253 expld
.section
= bfd_abs_section_ptr
;
1254 exp_fold_tree_1 (tree
);
1258 exp_value_fold (etree_type
*tree
)
1260 exp_fold_tree_no_dot (tree
);
1261 if (expld
.result
.valid_p
)
1263 tree
->type
.node_code
= INT
;
1264 tree
->value
.value
= expld
.result
.value
;
1265 tree
->value
.str
= NULL
;
1266 tree
->type
.node_class
= etree_value
;
1270 #define MAX(a, b) ((a) > (b) ? (a) : (b))
1273 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1275 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->binary
),
1276 sizeof (new_e
->value
)));
1277 new_e
->type
.node_code
= code
;
1278 new_e
->type
.filename
= lhs
->type
.filename
;
1279 new_e
->type
.lineno
= lhs
->type
.lineno
;
1280 new_e
->binary
.lhs
= lhs
;
1281 new_e
->binary
.rhs
= rhs
;
1282 new_e
->type
.node_class
= etree_binary
;
1283 if (lhs
->type
.node_class
== etree_value
1284 && rhs
->type
.node_class
== etree_value
1286 && code
!= DATA_SEGMENT_ALIGN
1287 && code
!= DATA_SEGMENT_RELRO_END
)
1288 exp_value_fold (new_e
);
1293 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1295 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->trinary
),
1296 sizeof (new_e
->value
)));
1297 new_e
->type
.node_code
= code
;
1298 new_e
->type
.filename
= cond
->type
.filename
;
1299 new_e
->type
.lineno
= cond
->type
.lineno
;
1300 new_e
->trinary
.lhs
= lhs
;
1301 new_e
->trinary
.cond
= cond
;
1302 new_e
->trinary
.rhs
= rhs
;
1303 new_e
->type
.node_class
= etree_trinary
;
1304 if (cond
->type
.node_class
== etree_value
1305 && lhs
->type
.node_class
== etree_value
1306 && rhs
->type
.node_class
== etree_value
)
1307 exp_value_fold (new_e
);
1312 exp_unop (int code
, etree_type
*child
)
1314 etree_type
*new_e
= (etree_type
*) stat_alloc (MAX (sizeof (new_e
->unary
),
1315 sizeof (new_e
->value
)));
1316 new_e
->unary
.type
.node_code
= code
;
1317 new_e
->unary
.type
.filename
= child
->type
.filename
;
1318 new_e
->unary
.type
.lineno
= child
->type
.lineno
;
1319 new_e
->unary
.child
= child
;
1320 new_e
->unary
.type
.node_class
= etree_unary
;
1321 if (child
->type
.node_class
== etree_value
1325 && code
!= DATA_SEGMENT_END
)
1326 exp_value_fold (new_e
);
1331 exp_nameop (int code
, const char *name
)
1333 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
1335 new_e
->name
.type
.node_code
= code
;
1336 new_e
->name
.type
.filename
= ldlex_filename ();
1337 new_e
->name
.type
.lineno
= lineno
;
1338 new_e
->name
.name
= name
;
1339 new_e
->name
.type
.node_class
= etree_name
;
1345 exp_assop (const char *dst
,
1347 enum node_tree_enum
class,
1352 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
1353 n
->assign
.type
.node_code
= '=';
1354 n
->assign
.type
.filename
= src
->type
.filename
;
1355 n
->assign
.type
.lineno
= src
->type
.lineno
;
1356 n
->assign
.type
.node_class
= class;
1357 n
->assign
.src
= src
;
1358 n
->assign
.dst
= dst
;
1359 n
->assign
.hidden
= hidden
;
1363 /* Handle linker script assignments and HIDDEN. */
1366 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1368 return exp_assop (dst
, src
, etree_assign
, hidden
);
1371 /* Handle --defsym command-line option. */
1374 exp_defsym (const char *dst
, etree_type
*src
)
1376 return exp_assop (dst
, src
, etree_assign
, FALSE
);
1379 /* Handle PROVIDE. */
1382 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1384 return exp_assop (dst
, src
, etree_provide
, hidden
);
1387 /* Handle ASSERT. */
1390 exp_assert (etree_type
*exp
, const char *message
)
1394 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1395 n
->assert_s
.type
.node_code
= '!';
1396 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1397 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1398 n
->assert_s
.type
.node_class
= etree_assert
;
1399 n
->assert_s
.child
= exp
;
1400 n
->assert_s
.message
= message
;
1405 exp_print_tree (etree_type
*tree
)
1407 bfd_boolean function_like
;
1409 if (config
.map_file
== NULL
)
1410 config
.map_file
= stderr
;
1414 minfo ("NULL TREE\n");
1418 switch (tree
->type
.node_class
)
1421 minfo ("0x%v", tree
->value
.value
);
1424 if (tree
->rel
.section
->owner
!= NULL
)
1425 minfo ("%pB:", tree
->rel
.section
->owner
);
1426 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1429 fputs (tree
->assign
.dst
, config
.map_file
);
1430 exp_print_token (tree
->type
.node_code
, TRUE
);
1431 exp_print_tree (tree
->assign
.src
);
1434 case etree_provided
:
1435 fprintf (config
.map_file
, "PROVIDE (%s = ", tree
->assign
.dst
);
1436 exp_print_tree (tree
->assign
.src
);
1437 fputc (')', config
.map_file
);
1440 function_like
= FALSE
;
1441 switch (tree
->type
.node_code
)
1446 case DATA_SEGMENT_ALIGN
:
1447 case DATA_SEGMENT_RELRO_END
:
1448 function_like
= TRUE
;
1451 /* Special handling because arguments are in reverse order and
1452 the segment name is quoted. */
1453 exp_print_token (tree
->type
.node_code
, FALSE
);
1454 fputs (" (\"", config
.map_file
);
1455 exp_print_tree (tree
->binary
.rhs
);
1456 fputs ("\", ", config
.map_file
);
1457 exp_print_tree (tree
->binary
.lhs
);
1458 fputc (')', config
.map_file
);
1463 exp_print_token (tree
->type
.node_code
, FALSE
);
1464 fputc (' ', config
.map_file
);
1466 fputc ('(', config
.map_file
);
1467 exp_print_tree (tree
->binary
.lhs
);
1469 fprintf (config
.map_file
, ", ");
1471 exp_print_token (tree
->type
.node_code
, TRUE
);
1472 exp_print_tree (tree
->binary
.rhs
);
1473 fputc (')', config
.map_file
);
1476 exp_print_tree (tree
->trinary
.cond
);
1477 fputc ('?', config
.map_file
);
1478 exp_print_tree (tree
->trinary
.lhs
);
1479 fputc (':', config
.map_file
);
1480 exp_print_tree (tree
->trinary
.rhs
);
1483 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1484 if (tree
->unary
.child
)
1486 fprintf (config
.map_file
, " (");
1487 exp_print_tree (tree
->unary
.child
);
1488 fputc (')', config
.map_file
);
1493 fprintf (config
.map_file
, "ASSERT (");
1494 exp_print_tree (tree
->assert_s
.child
);
1495 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1499 if (tree
->type
.node_code
== NAME
)
1500 fputs (tree
->name
.name
, config
.map_file
);
1503 exp_print_token (tree
->type
.node_code
, FALSE
);
1504 if (tree
->name
.name
)
1505 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1515 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1519 exp_fold_tree_no_dot (tree
);
1520 if (expld
.result
.valid_p
)
1521 return expld
.result
.value
;
1522 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1523 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1529 /* Return the smallest non-negative integer such that two raised to
1530 that power is at least as large as the vma evaluated at TREE, if
1531 TREE is a non-NULL expression that can be resolved. If TREE is
1532 NULL or cannot be resolved, return -1. */
1535 exp_get_power (etree_type
*tree
, char *name
)
1537 bfd_vma x
= exp_get_vma (tree
, -1, name
);
1541 if (x
== (bfd_vma
) -1)
1544 for (n
= 0, p2
= 1; p2
< x
; ++n
, p2
<<= 1)
1552 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1561 exp_fold_tree_no_dot (tree
);
1562 if (!expld
.result
.valid_p
)
1564 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1565 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1570 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1574 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1575 fill
->size
= (len
+ 1) / 2;
1577 s
= (unsigned char *) expld
.result
.str
;
1585 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1599 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1600 val
= expld
.result
.value
;
1601 fill
->data
[0] = (val
>> 24) & 0xff;
1602 fill
->data
[1] = (val
>> 16) & 0xff;
1603 fill
->data
[2] = (val
>> 8) & 0xff;
1604 fill
->data
[3] = (val
>> 0) & 0xff;
1611 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1615 exp_fold_tree_no_dot (tree
);
1617 if (expld
.result
.valid_p
)
1619 if (expld
.result
.section
!= NULL
)
1620 expld
.result
.value
+= expld
.result
.section
->vma
;
1621 return expld
.result
.value
;
1623 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1625 einfo (_("%F%P:%pS: nonconstant expression for %s\n"),
1633 align_n (bfd_vma value
, bfd_vma align
)
1638 value
= (value
+ align
- 1) / align
;
1639 return value
* align
;
1645 /* The value "13" is ad-hoc, somewhat related to the expected number of
1646 assignments in a linker script. */
1647 if (!bfd_hash_table_init_n (&definedness_table
,
1648 definedness_newfunc
,
1649 sizeof (struct definedness_hash_entry
),
1651 einfo (_("%F%P: can not create hash table: %E\n"));
1654 /* Convert absolute symbols defined by a script from "dot" (also
1655 SEGMENT_START or ORIGIN) outside of an output section statement,
1656 to section relative. */
1659 set_sym_sections (struct bfd_hash_entry
*bh
, void *inf ATTRIBUTE_UNUSED
)
1661 struct definedness_hash_entry
*def
= (struct definedness_hash_entry
*) bh
;
1662 if (def
->final_sec
!= bfd_abs_section_ptr
)
1664 struct bfd_link_hash_entry
*h
;
1665 h
= bfd_link_hash_lookup (link_info
.hash
, bh
->string
,
1666 FALSE
, FALSE
, TRUE
);
1668 && h
->type
== bfd_link_hash_defined
1669 && h
->u
.def
.section
== bfd_abs_section_ptr
)
1671 h
->u
.def
.value
-= def
->final_sec
->vma
;
1672 h
->u
.def
.section
= def
->final_sec
;
1679 ldexp_finalize_syms (void)
1681 bfd_hash_traverse (&definedness_table
, set_sym_sections
, NULL
);
1687 bfd_hash_table_free (&definedness_table
);