1 /* This module handles expression trees.
2 Copyright (C) 1991-2015 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. */
54 struct definedness_hash_entry
56 struct bfd_hash_entry root
;
57 unsigned int by_object
: 1;
58 unsigned int by_script
: 1;
59 unsigned int iteration
: 1;
62 static struct bfd_hash_table definedness_table
;
64 /* Print the string representation of the given token. Surround it
65 with spaces if INFIX_P is TRUE. */
68 exp_print_token (token_code_type code
, int infix_p
)
95 { LOG2CEIL
, "LOG2CEIL" },
103 { SECTIONS
, "SECTIONS" },
104 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
105 { MEMORY
, "MEMORY" },
106 { DEFINED
, "DEFINED" },
107 { TARGET_K
, "TARGET" },
108 { SEARCH_DIR
, "SEARCH_DIR" },
112 { ALIGNOF
, "ALIGNOF" },
113 { SIZEOF
, "SIZEOF" },
115 { LOADADDR
, "LOADADDR" },
116 { CONSTANT
, "CONSTANT" },
117 { ABSOLUTE
, "ABSOLUTE" },
120 { ASSERT_K
, "ASSERT" },
121 { REL
, "relocatable" },
122 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
123 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
124 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
125 { ORIGIN
, "ORIGIN" },
126 { LENGTH
, "LENGTH" },
127 { SEGMENT_START
, "SEGMENT_START" }
131 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
132 if (table
[idx
].code
== code
)
136 fputc (' ', config
.map_file
);
138 if (idx
< ARRAY_SIZE (table
))
139 fputs (table
[idx
].name
, config
.map_file
);
141 fputc (code
, config
.map_file
);
143 fprintf (config
.map_file
, "<code %d>", code
);
146 fputc (' ', config
.map_file
);
152 bfd_vma value
= expld
.result
.value
;
154 bfd_boolean round_up
= FALSE
;
159 /* If more than one bit is set in the value we will need to round up. */
160 if ((value
> 1) && (value
& 1))
167 expld
.result
.section
= NULL
;
168 expld
.result
.value
= result
;
174 if (expld
.result
.section
!= NULL
)
175 expld
.result
.value
+= expld
.result
.section
->vma
;
176 expld
.result
.section
= bfd_abs_section_ptr
;
180 new_abs (bfd_vma value
)
182 expld
.result
.valid_p
= TRUE
;
183 expld
.result
.section
= bfd_abs_section_ptr
;
184 expld
.result
.value
= value
;
185 expld
.result
.str
= NULL
;
189 exp_intop (bfd_vma value
)
191 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
192 new_e
->type
.node_code
= INT
;
193 new_e
->type
.filename
= ldlex_filename ();
194 new_e
->type
.lineno
= lineno
;
195 new_e
->value
.value
= value
;
196 new_e
->value
.str
= NULL
;
197 new_e
->type
.node_class
= etree_value
;
202 exp_bigintop (bfd_vma value
, char *str
)
204 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
205 new_e
->type
.node_code
= INT
;
206 new_e
->type
.filename
= ldlex_filename ();
207 new_e
->type
.lineno
= lineno
;
208 new_e
->value
.value
= value
;
209 new_e
->value
.str
= str
;
210 new_e
->type
.node_class
= etree_value
;
214 /* Build an expression representing an unnamed relocatable value. */
217 exp_relop (asection
*section
, bfd_vma value
)
219 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->rel
));
220 new_e
->type
.node_code
= REL
;
221 new_e
->type
.filename
= ldlex_filename ();
222 new_e
->type
.lineno
= lineno
;
223 new_e
->type
.node_class
= etree_rel
;
224 new_e
->rel
.section
= section
;
225 new_e
->rel
.value
= value
;
230 new_number (bfd_vma value
)
232 expld
.result
.valid_p
= TRUE
;
233 expld
.result
.value
= value
;
234 expld
.result
.str
= NULL
;
235 expld
.result
.section
= NULL
;
239 new_rel (bfd_vma value
, asection
*section
)
241 expld
.result
.valid_p
= TRUE
;
242 expld
.result
.value
= value
;
243 expld
.result
.str
= NULL
;
244 expld
.result
.section
= section
;
248 new_rel_from_abs (bfd_vma value
)
250 asection
*s
= expld
.section
;
252 if (s
== bfd_abs_section_ptr
&& expld
.phase
== lang_final_phase_enum
)
253 s
= section_for_dot ();
254 expld
.result
.valid_p
= TRUE
;
255 expld
.result
.value
= value
- s
->vma
;
256 expld
.result
.str
= NULL
;
257 expld
.result
.section
= s
;
260 /* New-function for the definedness hash table. */
262 static struct bfd_hash_entry
*
263 definedness_newfunc (struct bfd_hash_entry
*entry
,
264 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
265 const char *name ATTRIBUTE_UNUSED
)
267 struct definedness_hash_entry
*ret
= (struct definedness_hash_entry
*) entry
;
270 ret
= (struct definedness_hash_entry
*)
271 bfd_hash_allocate (table
, sizeof (struct definedness_hash_entry
));
274 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
282 /* Called during processing of linker script script expressions.
283 For symbols assigned in a linker script, return a struct describing
284 where the symbol is defined relative to the current expression,
285 otherwise return NULL. */
287 static struct definedness_hash_entry
*
288 symbol_defined (const char *name
)
290 return ((struct definedness_hash_entry
*)
291 bfd_hash_lookup (&definedness_table
, name
, FALSE
, FALSE
));
294 /* Update the definedness state of NAME. Return FALSE if script symbol
295 is multiply defining a strong symbol in an object. */
298 update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
301 struct definedness_hash_entry
*defentry
302 = (struct definedness_hash_entry
*)
303 bfd_hash_lookup (&definedness_table
, name
, TRUE
, FALSE
);
305 if (defentry
== NULL
)
306 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
308 /* If the symbol was already defined, and not by a script, then it
309 must be defined by an object file or by the linker target code. */
311 if (!defentry
->by_script
312 && (h
->type
== bfd_link_hash_defined
313 || h
->type
== bfd_link_hash_defweak
314 || h
->type
== bfd_link_hash_common
))
316 defentry
->by_object
= 1;
317 if (h
->type
== bfd_link_hash_defined
318 && h
->u
.def
.section
->output_section
!= NULL
323 defentry
->by_script
= 1;
324 defentry
->iteration
= lang_statement_iteration
;
329 fold_unary (etree_type
*tree
)
331 exp_fold_tree_1 (tree
->unary
.child
);
332 if (expld
.result
.valid_p
)
334 switch (tree
->type
.node_code
)
337 if (expld
.phase
!= lang_first_phase_enum
)
338 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
340 expld
.result
.valid_p
= FALSE
;
352 expld
.result
.value
= ~expld
.result
.value
;
356 expld
.result
.value
= !expld
.result
.value
;
360 expld
.result
.value
= -expld
.result
.value
;
364 /* Return next place aligned to value. */
365 if (expld
.phase
!= lang_first_phase_enum
)
368 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
371 expld
.result
.valid_p
= FALSE
;
374 case DATA_SEGMENT_END
:
375 if (expld
.phase
== lang_first_phase_enum
376 || expld
.section
!= bfd_abs_section_ptr
)
378 expld
.result
.valid_p
= FALSE
;
380 else if (expld
.dataseg
.phase
== exp_dataseg_align_seen
381 || expld
.dataseg
.phase
== exp_dataseg_relro_seen
)
383 expld
.dataseg
.phase
= exp_dataseg_end_seen
;
384 expld
.dataseg
.end
= expld
.result
.value
;
386 else if (expld
.dataseg
.phase
== exp_dataseg_done
387 || expld
.dataseg
.phase
== exp_dataseg_adjust
388 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
393 expld
.result
.valid_p
= FALSE
;
404 fold_binary (etree_type
*tree
)
406 etree_value_type lhs
;
407 exp_fold_tree_1 (tree
->binary
.lhs
);
409 /* The SEGMENT_START operator is special because its first
410 operand is a string, not the name of a symbol. Note that the
411 operands have been swapped, so binary.lhs is second (default)
412 operand, binary.rhs is first operand. */
413 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
415 const char *segment_name
;
418 /* Check to see if the user has overridden the default
420 segment_name
= tree
->binary
.rhs
->name
.name
;
421 for (seg
= segments
; seg
; seg
= seg
->next
)
422 if (strcmp (seg
->name
, segment_name
) == 0)
425 && config
.magic_demand_paged
426 && (seg
->value
% config
.maxpagesize
) != 0)
427 einfo (_("%P: warning: address of `%s' isn't multiple of maximum page size\n"),
430 new_rel_from_abs (seg
->value
);
437 exp_fold_tree_1 (tree
->binary
.rhs
);
438 expld
.result
.valid_p
&= lhs
.valid_p
;
440 if (expld
.result
.valid_p
)
442 if (lhs
.section
!= expld
.result
.section
)
444 /* If the values are from different sections, and neither is
445 just a number, make both the source arguments absolute. */
446 if (expld
.result
.section
!= NULL
447 && lhs
.section
!= NULL
)
450 lhs
.value
+= lhs
.section
->vma
;
451 lhs
.section
= bfd_abs_section_ptr
;
454 /* If the rhs is just a number, keep the lhs section. */
455 else if (expld
.result
.section
== NULL
)
457 expld
.result
.section
= lhs
.section
;
458 /* Make this NULL so that we know one of the operands
459 was just a number, for later tests. */
463 /* At this point we know that both operands have the same
464 section, or at least one of them is a plain number. */
466 switch (tree
->type
.node_code
)
468 /* Arithmetic operators, bitwise AND, bitwise OR and XOR
469 keep the section of one of their operands only when the
470 other operand is a plain number. Losing the section when
471 operating on two symbols, ie. a result of a plain number,
472 is required for subtraction and XOR. It's justifiable
473 for the other operations on the grounds that adding,
474 multiplying etc. two section relative values does not
475 really make sense unless they are just treated as
477 The same argument could be made for many expressions
478 involving one symbol and a number. For example,
479 "1 << x" and "100 / x" probably should not be given the
480 section of x. The trouble is that if we fuss about such
481 things the rules become complex and it is onerous to
482 document ld expression evaluation. */
485 expld.result.value = lhs.value y expld.result.value; \
486 if (expld.result.section == lhs.section) \
487 expld.result.section = NULL; \
490 /* Comparison operators, logical AND, and logical OR always
491 return a plain number. */
494 expld.result.value = lhs.value y expld.result.value; \
495 expld.result.section = NULL; \
516 if (expld
.result
.value
!= 0)
517 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
518 % (bfd_signed_vma
) expld
.result
.value
);
519 else if (expld
.phase
!= lang_mark_phase_enum
)
520 einfo (_("%F%S %% by zero\n"), tree
->binary
.rhs
);
521 if (expld
.result
.section
== lhs
.section
)
522 expld
.result
.section
= NULL
;
526 if (expld
.result
.value
!= 0)
527 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
528 / (bfd_signed_vma
) expld
.result
.value
);
529 else if (expld
.phase
!= lang_mark_phase_enum
)
530 einfo (_("%F%S / by zero\n"), tree
->binary
.rhs
);
531 if (expld
.result
.section
== lhs
.section
)
532 expld
.result
.section
= NULL
;
536 if (lhs
.value
> expld
.result
.value
)
537 expld
.result
.value
= lhs
.value
;
541 if (lhs
.value
< expld
.result
.value
)
542 expld
.result
.value
= lhs
.value
;
546 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
549 case DATA_SEGMENT_ALIGN
:
550 expld
.dataseg
.relro
= exp_dataseg_relro_start
;
551 if (expld
.phase
== lang_first_phase_enum
552 || expld
.section
!= bfd_abs_section_ptr
)
553 expld
.result
.valid_p
= FALSE
;
556 bfd_vma maxpage
= lhs
.value
;
557 bfd_vma commonpage
= expld
.result
.value
;
559 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
560 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
561 expld
.result
.value
= expld
.dataseg
.base
;
562 else if (expld
.dataseg
.phase
== exp_dataseg_adjust
)
564 if (commonpage
< maxpage
)
565 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
566 & (maxpage
- commonpage
));
570 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
571 if (expld
.dataseg
.phase
== exp_dataseg_done
)
575 else if (expld
.dataseg
.phase
== exp_dataseg_none
)
577 expld
.dataseg
.phase
= exp_dataseg_align_seen
;
578 expld
.dataseg
.base
= expld
.result
.value
;
579 expld
.dataseg
.pagesize
= commonpage
;
580 expld
.dataseg
.maxpagesize
= maxpage
;
581 expld
.dataseg
.relro_end
= 0;
584 expld
.result
.valid_p
= FALSE
;
589 case DATA_SEGMENT_RELRO_END
:
590 /* Operands swapped! DATA_SEGMENT_RELRO_END(offset,exp)
591 has offset in expld.result and exp in lhs. */
592 expld
.dataseg
.relro
= exp_dataseg_relro_end
;
593 expld
.dataseg
.relro_offset
= expld
.result
.value
;
594 if (expld
.phase
== lang_first_phase_enum
595 || expld
.section
!= bfd_abs_section_ptr
)
596 expld
.result
.valid_p
= FALSE
;
597 else if (expld
.dataseg
.phase
== exp_dataseg_align_seen
598 || expld
.dataseg
.phase
== exp_dataseg_adjust
599 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
600 || expld
.dataseg
.phase
== exp_dataseg_done
)
602 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
603 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
604 expld
.dataseg
.relro_end
= lhs
.value
+ expld
.result
.value
;
606 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
607 && (expld
.dataseg
.relro_end
608 & (expld
.dataseg
.pagesize
- 1)))
610 expld
.dataseg
.relro_end
+= expld
.dataseg
.pagesize
- 1;
611 expld
.dataseg
.relro_end
&= ~(expld
.dataseg
.pagesize
- 1);
612 expld
.result
.value
= (expld
.dataseg
.relro_end
613 - expld
.result
.value
);
616 expld
.result
.value
= lhs
.value
;
618 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
)
619 expld
.dataseg
.phase
= exp_dataseg_relro_seen
;
622 expld
.result
.valid_p
= FALSE
;
632 fold_trinary (etree_type
*tree
)
634 exp_fold_tree_1 (tree
->trinary
.cond
);
635 if (expld
.result
.valid_p
)
636 exp_fold_tree_1 (expld
.result
.value
638 : tree
->trinary
.rhs
);
642 fold_name (etree_type
*tree
)
644 memset (&expld
.result
, 0, sizeof (expld
.result
));
646 switch (tree
->type
.node_code
)
649 if (expld
.phase
!= lang_first_phase_enum
)
651 bfd_vma hdr_size
= 0;
652 /* Don't find the real header size if only marking sections;
653 The bfd function may cache incorrect data. */
654 if (expld
.phase
!= lang_mark_phase_enum
)
655 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
656 new_number (hdr_size
);
661 if (expld
.phase
!= lang_first_phase_enum
)
663 struct bfd_link_hash_entry
*h
;
664 struct definedness_hash_entry
*def
;
666 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
670 new_number (h
!= NULL
671 && (h
->type
== bfd_link_hash_defined
672 || h
->type
== bfd_link_hash_defweak
673 || h
->type
== bfd_link_hash_common
)
674 && ((def
= symbol_defined (tree
->name
.name
)) == NULL
676 || def
->iteration
== (lang_statement_iteration
& 1)));
681 if (expld
.assign_name
!= NULL
682 && strcmp (expld
.assign_name
, tree
->name
.name
) == 0)
684 /* Self-assignment is only allowed for absolute symbols
685 defined in a linker script. */
686 struct bfd_link_hash_entry
*h
;
687 struct definedness_hash_entry
*def
;
689 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
694 && (h
->type
== bfd_link_hash_defined
695 || h
->type
== bfd_link_hash_defweak
)
696 && h
->u
.def
.section
== bfd_abs_section_ptr
697 && (def
= symbol_defined (tree
->name
.name
)) != NULL
698 && def
->iteration
== (lang_statement_iteration
& 1)))
699 expld
.assign_name
= NULL
;
701 if (expld
.phase
== lang_first_phase_enum
)
703 else if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
704 new_rel_from_abs (expld
.dot
);
707 struct bfd_link_hash_entry
*h
;
709 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
714 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
715 else if (h
->type
== bfd_link_hash_defined
716 || h
->type
== bfd_link_hash_defweak
)
718 asection
*output_section
;
720 output_section
= h
->u
.def
.section
->output_section
;
721 if (output_section
== NULL
)
723 if (expld
.phase
== lang_mark_phase_enum
)
724 new_rel (h
->u
.def
.value
, h
->u
.def
.section
);
726 einfo (_("%X%S: unresolvable symbol `%s'"
727 " referenced in expression\n"),
728 tree
, tree
->name
.name
);
730 else if (output_section
== bfd_abs_section_ptr
731 && (expld
.section
!= bfd_abs_section_ptr
732 || config
.sane_expr
))
733 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
735 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
738 else if (expld
.phase
== lang_final_phase_enum
739 || (expld
.phase
!= lang_mark_phase_enum
740 && expld
.assigning_to_dot
))
741 einfo (_("%F%S: undefined symbol `%s'"
742 " referenced in expression\n"),
743 tree
, tree
->name
.name
);
744 else if (h
->type
== bfd_link_hash_new
)
746 h
->type
= bfd_link_hash_undefined
;
747 h
->u
.undef
.abfd
= NULL
;
748 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
749 bfd_link_add_undef (link_info
.hash
, h
);
755 if (expld
.phase
!= lang_first_phase_enum
)
757 lang_output_section_statement_type
*os
;
759 os
= lang_output_section_find (tree
->name
.name
);
762 if (expld
.phase
== lang_final_phase_enum
)
763 einfo (_("%F%S: undefined section `%s'"
764 " referenced in expression\n"),
765 tree
, tree
->name
.name
);
767 else if (os
->processed_vma
)
768 new_rel (0, os
->bfd_section
);
773 if (expld
.phase
!= lang_first_phase_enum
)
775 lang_output_section_statement_type
*os
;
777 os
= lang_output_section_find (tree
->name
.name
);
780 if (expld
.phase
== lang_final_phase_enum
)
781 einfo (_("%F%S: undefined section `%s'"
782 " referenced in expression\n"),
783 tree
, tree
->name
.name
);
785 else if (os
->processed_lma
)
787 if (os
->load_base
== NULL
)
788 new_abs (os
->bfd_section
->lma
);
791 exp_fold_tree_1 (os
->load_base
);
792 if (expld
.result
.valid_p
)
801 if (expld
.phase
!= lang_first_phase_enum
)
803 lang_output_section_statement_type
*os
;
805 os
= lang_output_section_find (tree
->name
.name
);
808 if (expld
.phase
== lang_final_phase_enum
)
809 einfo (_("%F%S: undefined section `%s'"
810 " referenced in expression\n"),
811 tree
, tree
->name
.name
);
814 else if (os
->bfd_section
!= NULL
)
818 if (tree
->type
.node_code
== SIZEOF
)
819 val
= (os
->bfd_section
->size
820 / bfd_octets_per_byte (link_info
.output_bfd
));
822 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
833 if (expld
.phase
!= lang_first_phase_enum
)
835 lang_memory_region_type
*mem
;
837 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
839 new_number (mem
->length
);
841 einfo (_("%F%S: undefined MEMORY region `%s'"
842 " referenced in expression\n"),
843 tree
, tree
->name
.name
);
849 if (expld
.phase
!= lang_first_phase_enum
)
851 lang_memory_region_type
*mem
;
853 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
855 new_rel_from_abs (mem
->origin
);
857 einfo (_("%F%S: undefined MEMORY region `%s'"
858 " referenced in expression\n"),
859 tree
, tree
->name
.name
);
864 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
865 new_number (config
.maxpagesize
);
866 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
867 new_number (config
.commonpagesize
);
869 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
870 tree
, tree
->name
.name
);
879 /* Return true if TREE is '.'. */
882 is_dot (const etree_type
*tree
)
884 return (tree
->type
.node_class
== etree_name
885 && tree
->type
.node_code
== NAME
886 && tree
->name
.name
[0] == '.'
887 && tree
->name
.name
[1] == 0);
890 /* Return true if TREE is a constant equal to VAL. */
893 is_value (const etree_type
*tree
, bfd_vma val
)
895 return (tree
->type
.node_class
== etree_value
896 && tree
->value
.value
== val
);
899 /* Return true if TREE is an absolute symbol equal to VAL defined in
903 is_sym_value (const etree_type
*tree
, bfd_vma val
)
905 struct bfd_link_hash_entry
*h
;
906 struct definedness_hash_entry
*def
;
908 return (tree
->type
.node_class
== etree_name
909 && tree
->type
.node_code
== NAME
910 && (def
= symbol_defined (tree
->name
.name
)) != NULL
912 && def
->iteration
== (lang_statement_iteration
& 1)
913 && (h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
916 FALSE
, FALSE
, TRUE
)) != NULL
917 && h
->type
== bfd_link_hash_defined
918 && h
->u
.def
.section
== bfd_abs_section_ptr
919 && h
->u
.def
.value
== val
);
922 /* Return true if TREE is ". != 0". */
925 is_dot_ne_0 (const etree_type
*tree
)
927 return (tree
->type
.node_class
== etree_binary
928 && tree
->type
.node_code
== NE
929 && is_dot (tree
->binary
.lhs
)
930 && is_value (tree
->binary
.rhs
, 0));
933 /* Return true if TREE is ". = . + 0" or ". = . + sym" where sym is an
934 absolute constant with value 0 defined in a linker script. */
937 is_dot_plus_0 (const etree_type
*tree
)
939 return (tree
->type
.node_class
== etree_binary
940 && tree
->type
.node_code
== '+'
941 && is_dot (tree
->binary
.lhs
)
942 && (is_value (tree
->binary
.rhs
, 0)
943 || is_sym_value (tree
->binary
.rhs
, 0)));
946 /* Return true if TREE is "ALIGN (. != 0 ? some_expression : 1)". */
949 is_align_conditional (const etree_type
*tree
)
951 if (tree
->type
.node_class
== etree_unary
952 && tree
->type
.node_code
== ALIGN_K
)
954 tree
= tree
->unary
.child
;
955 return (tree
->type
.node_class
== etree_trinary
956 && is_dot_ne_0 (tree
->trinary
.cond
)
957 && is_value (tree
->trinary
.rhs
, 1));
963 exp_fold_tree_1 (etree_type
*tree
)
967 memset (&expld
.result
, 0, sizeof (expld
.result
));
971 switch (tree
->type
.node_class
)
974 if (expld
.section
== bfd_abs_section_ptr
975 && !config
.sane_expr
)
976 new_abs (tree
->value
.value
);
978 new_number (tree
->value
.value
);
979 expld
.result
.str
= tree
->value
.str
;
983 if (expld
.phase
!= lang_first_phase_enum
)
985 asection
*output_section
= tree
->rel
.section
->output_section
;
986 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
990 memset (&expld
.result
, 0, sizeof (expld
.result
));
994 exp_fold_tree_1 (tree
->assert_s
.child
);
995 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
996 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
1008 fold_trinary (tree
);
1013 case etree_provided
:
1014 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
1016 if (tree
->type
.node_class
!= etree_assign
)
1017 einfo (_("%F%S can not PROVIDE assignment to"
1018 " location counter\n"), tree
);
1019 if (expld
.phase
!= lang_first_phase_enum
)
1021 /* Notify the folder that this is an assignment to dot. */
1022 expld
.assigning_to_dot
= TRUE
;
1023 exp_fold_tree_1 (tree
->assign
.src
);
1024 expld
.assigning_to_dot
= FALSE
;
1026 /* If we are assigning to dot inside an output section
1027 arrange to keep the section, except for certain
1028 expressions that evaluate to zero. We ignore . = 0,
1029 . = . + 0, and . = ALIGN (. != 0 ? expr : 1).
1030 We can't ignore all expressions that evaluate to zero
1031 because an otherwise empty section might have padding
1032 added by an alignment expression that changes with
1033 relaxation. Such a section might have zero size
1034 before relaxation and so be stripped incorrectly. */
1035 if (expld
.phase
== lang_mark_phase_enum
1036 && expld
.section
!= bfd_abs_section_ptr
1037 && !(expld
.result
.valid_p
1038 && expld
.result
.value
== 0
1039 && (is_value (tree
->assign
.src
, 0)
1040 || is_sym_value (tree
->assign
.src
, 0)
1041 || is_dot_plus_0 (tree
->assign
.src
)
1042 || is_align_conditional (tree
->assign
.src
))))
1043 expld
.section
->flags
|= SEC_KEEP
;
1045 if (!expld
.result
.valid_p
)
1047 if (expld
.phase
!= lang_mark_phase_enum
)
1048 einfo (_("%F%S invalid assignment to"
1049 " location counter\n"), tree
);
1051 else if (expld
.dotp
== NULL
)
1052 einfo (_("%F%S assignment to location counter"
1053 " invalid outside of SECTIONS\n"), tree
);
1055 /* After allocation, assignment to dot should not be
1056 done inside an output section since allocation adds a
1057 padding statement that effectively duplicates the
1059 else if (expld
.phase
<= lang_allocating_phase_enum
1060 || expld
.section
== bfd_abs_section_ptr
)
1064 nextdot
= expld
.result
.value
;
1065 if (expld
.result
.section
!= NULL
)
1066 nextdot
+= expld
.result
.section
->vma
;
1068 nextdot
+= expld
.section
->vma
;
1069 if (nextdot
< expld
.dot
1070 && expld
.section
!= bfd_abs_section_ptr
)
1071 einfo (_("%F%S cannot move location counter backwards"
1072 " (from %V to %V)\n"),
1073 tree
, expld
.dot
, nextdot
);
1076 expld
.dot
= nextdot
;
1077 *expld
.dotp
= nextdot
;
1082 memset (&expld
.result
, 0, sizeof (expld
.result
));
1086 struct bfd_link_hash_entry
*h
= NULL
;
1088 if (tree
->type
.node_class
== etree_provide
)
1090 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1091 FALSE
, FALSE
, TRUE
);
1093 || !(h
->type
== bfd_link_hash_new
1094 || h
->type
== bfd_link_hash_undefined
1097 /* Do nothing. The symbol was never referenced, or
1098 was defined in some object file. Undefined weak
1099 symbols stay undefined. */
1104 expld
.assign_name
= tree
->assign
.dst
;
1105 exp_fold_tree_1 (tree
->assign
.src
);
1106 /* expld.assign_name remaining equal to tree->assign.dst
1107 below indicates the evaluation of tree->assign.src did
1108 not use the value of tree->assign.dst. We don't allow
1109 self assignment until the final phase for two reasons:
1110 1) Expressions are evaluated multiple times. With
1111 relaxation, the number of times may vary.
1112 2) Section relative symbol values cannot be correctly
1113 converted to absolute values, as is required by many
1114 expressions, until final section sizing is complete. */
1115 if ((expld
.result
.valid_p
1116 && (expld
.phase
== lang_final_phase_enum
1117 || expld
.assign_name
!= NULL
))
1118 || (expld
.phase
<= lang_mark_phase_enum
1119 && tree
->type
.node_class
== etree_assign
1120 && tree
->assign
.defsym
))
1124 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1127 einfo (_("%P%F:%s: hash creation failed\n"),
1131 if (expld
.result
.section
== NULL
)
1132 expld
.result
.section
= expld
.section
;
1133 if (!update_definedness (tree
->assign
.dst
, h
) && 0)
1135 /* Symbol was already defined. For now this error
1136 is disabled because it causes failures in the ld
1137 testsuite: ld-elf/var1, ld-scripts/defined5, and
1138 ld-scripts/pr14962. Some of these no doubt
1139 reflect scripts used in the wild. */
1140 (*link_info
.callbacks
->multiple_definition
)
1141 (&link_info
, h
, link_info
.output_bfd
,
1142 expld
.result
.section
, expld
.result
.value
);
1144 h
->type
= bfd_link_hash_defined
;
1145 h
->u
.def
.value
= expld
.result
.value
;
1146 h
->u
.def
.section
= expld
.result
.section
;
1147 if (tree
->type
.node_class
== etree_provide
)
1148 tree
->type
.node_class
= etree_provided
;
1150 /* Copy the symbol type if this is a simple assignment of
1151 one symbol to another. This could be more general
1152 (e.g. a ?: operator with NAMEs in each branch). */
1153 if (tree
->assign
.src
->type
.node_class
== etree_name
)
1155 struct bfd_link_hash_entry
*hsrc
;
1157 hsrc
= bfd_link_hash_lookup (link_info
.hash
,
1158 tree
->assign
.src
->name
.name
,
1159 FALSE
, FALSE
, TRUE
);
1161 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
, h
,
1165 else if (expld
.phase
== lang_final_phase_enum
)
1167 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
1168 FALSE
, FALSE
, TRUE
);
1170 && h
->type
== bfd_link_hash_new
)
1171 h
->type
= bfd_link_hash_undefined
;
1173 expld
.assign_name
= NULL
;
1183 memset (&expld
.result
, 0, sizeof (expld
.result
));
1189 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
1193 expld
.section
= current_section
;
1194 exp_fold_tree_1 (tree
);
1198 exp_fold_tree_no_dot (etree_type
*tree
)
1202 expld
.section
= bfd_abs_section_ptr
;
1203 exp_fold_tree_1 (tree
);
1207 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
1209 etree_type value
, *new_e
;
1211 value
.type
.node_code
= code
;
1212 value
.type
.filename
= lhs
->type
.filename
;
1213 value
.type
.lineno
= lhs
->type
.lineno
;
1214 value
.binary
.lhs
= lhs
;
1215 value
.binary
.rhs
= rhs
;
1216 value
.type
.node_class
= etree_binary
;
1217 exp_fold_tree_no_dot (&value
);
1218 if (expld
.result
.valid_p
)
1219 return exp_intop (expld
.result
.value
);
1221 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->binary
));
1222 memcpy (new_e
, &value
, sizeof (new_e
->binary
));
1227 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
1229 etree_type value
, *new_e
;
1231 value
.type
.node_code
= code
;
1232 value
.type
.filename
= cond
->type
.filename
;
1233 value
.type
.lineno
= cond
->type
.lineno
;
1234 value
.trinary
.lhs
= lhs
;
1235 value
.trinary
.cond
= cond
;
1236 value
.trinary
.rhs
= rhs
;
1237 value
.type
.node_class
= etree_trinary
;
1238 exp_fold_tree_no_dot (&value
);
1239 if (expld
.result
.valid_p
)
1240 return exp_intop (expld
.result
.value
);
1242 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->trinary
));
1243 memcpy (new_e
, &value
, sizeof (new_e
->trinary
));
1248 exp_unop (int code
, etree_type
*child
)
1250 etree_type value
, *new_e
;
1252 value
.unary
.type
.node_code
= code
;
1253 value
.unary
.type
.filename
= child
->type
.filename
;
1254 value
.unary
.type
.lineno
= child
->type
.lineno
;
1255 value
.unary
.child
= child
;
1256 value
.unary
.type
.node_class
= etree_unary
;
1257 exp_fold_tree_no_dot (&value
);
1258 if (expld
.result
.valid_p
)
1259 return exp_intop (expld
.result
.value
);
1261 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->unary
));
1262 memcpy (new_e
, &value
, sizeof (new_e
->unary
));
1267 exp_nameop (int code
, const char *name
)
1269 etree_type value
, *new_e
;
1271 value
.name
.type
.node_code
= code
;
1272 value
.name
.type
.filename
= ldlex_filename ();
1273 value
.name
.type
.lineno
= lineno
;
1274 value
.name
.name
= name
;
1275 value
.name
.type
.node_class
= etree_name
;
1277 exp_fold_tree_no_dot (&value
);
1278 if (expld
.result
.valid_p
)
1279 return exp_intop (expld
.result
.value
);
1281 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
1282 memcpy (new_e
, &value
, sizeof (new_e
->name
));
1288 exp_assop (const char *dst
,
1290 enum node_tree_enum
class,
1296 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
1297 n
->assign
.type
.node_code
= '=';
1298 n
->assign
.type
.filename
= src
->type
.filename
;
1299 n
->assign
.type
.lineno
= src
->type
.lineno
;
1300 n
->assign
.type
.node_class
= class;
1301 n
->assign
.src
= src
;
1302 n
->assign
.dst
= dst
;
1303 n
->assign
.defsym
= defsym
;
1304 n
->assign
.hidden
= hidden
;
1308 /* Handle linker script assignments and HIDDEN. */
1311 exp_assign (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1313 return exp_assop (dst
, src
, etree_assign
, FALSE
, hidden
);
1316 /* Handle --defsym command-line option. */
1319 exp_defsym (const char *dst
, etree_type
*src
)
1321 return exp_assop (dst
, src
, etree_assign
, TRUE
, FALSE
);
1324 /* Handle PROVIDE. */
1327 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
1329 return exp_assop (dst
, src
, etree_provide
, FALSE
, hidden
);
1332 /* Handle ASSERT. */
1335 exp_assert (etree_type
*exp
, const char *message
)
1339 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1340 n
->assert_s
.type
.node_code
= '!';
1341 n
->assert_s
.type
.filename
= exp
->type
.filename
;
1342 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1343 n
->assert_s
.type
.node_class
= etree_assert
;
1344 n
->assert_s
.child
= exp
;
1345 n
->assert_s
.message
= message
;
1350 exp_print_tree (etree_type
*tree
)
1352 bfd_boolean function_like
;
1354 if (config
.map_file
== NULL
)
1355 config
.map_file
= stderr
;
1359 minfo ("NULL TREE\n");
1363 switch (tree
->type
.node_class
)
1366 minfo ("0x%v", tree
->value
.value
);
1369 if (tree
->rel
.section
->owner
!= NULL
)
1370 minfo ("%B:", tree
->rel
.section
->owner
);
1371 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1374 fputs (tree
->assign
.dst
, config
.map_file
);
1375 exp_print_token (tree
->type
.node_code
, TRUE
);
1376 exp_print_tree (tree
->assign
.src
);
1379 case etree_provided
:
1380 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1381 exp_print_tree (tree
->assign
.src
);
1382 fputc (')', config
.map_file
);
1385 function_like
= FALSE
;
1386 switch (tree
->type
.node_code
)
1391 case DATA_SEGMENT_ALIGN
:
1392 case DATA_SEGMENT_RELRO_END
:
1393 function_like
= TRUE
;
1396 /* Special handling because arguments are in reverse order and
1397 the segment name is quoted. */
1398 exp_print_token (tree
->type
.node_code
, FALSE
);
1399 fputs (" (\"", config
.map_file
);
1400 exp_print_tree (tree
->binary
.rhs
);
1401 fputs ("\", ", config
.map_file
);
1402 exp_print_tree (tree
->binary
.lhs
);
1403 fputc (')', config
.map_file
);
1408 exp_print_token (tree
->type
.node_code
, FALSE
);
1409 fputc (' ', config
.map_file
);
1411 fputc ('(', config
.map_file
);
1412 exp_print_tree (tree
->binary
.lhs
);
1414 fprintf (config
.map_file
, ", ");
1416 exp_print_token (tree
->type
.node_code
, TRUE
);
1417 exp_print_tree (tree
->binary
.rhs
);
1418 fputc (')', config
.map_file
);
1421 exp_print_tree (tree
->trinary
.cond
);
1422 fputc ('?', config
.map_file
);
1423 exp_print_tree (tree
->trinary
.lhs
);
1424 fputc (':', config
.map_file
);
1425 exp_print_tree (tree
->trinary
.rhs
);
1428 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1429 if (tree
->unary
.child
)
1431 fprintf (config
.map_file
, " (");
1432 exp_print_tree (tree
->unary
.child
);
1433 fputc (')', config
.map_file
);
1438 fprintf (config
.map_file
, "ASSERT (");
1439 exp_print_tree (tree
->assert_s
.child
);
1440 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1444 if (tree
->type
.node_code
== NAME
)
1445 fputs (tree
->name
.name
, config
.map_file
);
1448 exp_print_token (tree
->type
.node_code
, FALSE
);
1449 if (tree
->name
.name
)
1450 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1460 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1464 exp_fold_tree_no_dot (tree
);
1465 if (expld
.result
.valid_p
)
1466 return expld
.result
.value
;
1467 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1468 einfo (_("%F%S: nonconstant expression for %s\n"),
1475 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1477 return exp_get_vma (tree
, def
, name
);
1481 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1490 exp_fold_tree_no_dot (tree
);
1491 if (!expld
.result
.valid_p
)
1493 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1494 einfo (_("%F%S: nonconstant expression for %s\n"),
1499 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1503 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1504 fill
->size
= (len
+ 1) / 2;
1506 s
= (unsigned char *) expld
.result
.str
;
1514 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1528 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1529 val
= expld
.result
.value
;
1530 fill
->data
[0] = (val
>> 24) & 0xff;
1531 fill
->data
[1] = (val
>> 16) & 0xff;
1532 fill
->data
[2] = (val
>> 8) & 0xff;
1533 fill
->data
[3] = (val
>> 0) & 0xff;
1540 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1544 exp_fold_tree_no_dot (tree
);
1546 if (expld
.result
.valid_p
)
1548 if (expld
.result
.section
!= NULL
)
1549 expld
.result
.value
+= expld
.result
.section
->vma
;
1550 return expld
.result
.value
;
1552 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1554 einfo (_("%F%S: nonconstant expression for %s\n"),
1562 align_n (bfd_vma value
, bfd_vma align
)
1567 value
= (value
+ align
- 1) / align
;
1568 return value
* align
;
1574 /* The value "13" is ad-hoc, somewhat related to the expected number of
1575 assignments in a linker script. */
1576 if (!bfd_hash_table_init_n (&definedness_table
,
1577 definedness_newfunc
,
1578 sizeof (struct definedness_hash_entry
),
1580 einfo (_("%P%F: can not create hash table: %E\n"));
1586 bfd_hash_table_free (&definedness_table
);