1 /* This module handles expression trees.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
7 This file is part of the GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
25 /* This module is in charge of working out the contents of expressions.
27 It has to keep track of the relative/absness of a symbol etc. This
28 is done by keeping all values in a struct (an etree_value_type)
29 which contains a value, a section to which it is relative and a
43 #include "libiberty.h"
44 #include "safe-ctype.h"
46 static void exp_fold_tree_1 (etree_type
*);
47 static bfd_vma
align_n (bfd_vma
, bfd_vma
);
49 segment_type
*segments
;
51 struct ldexp_control expld
;
53 /* Print the string representation of the given token. Surround it
54 with spaces if INFIX_P is TRUE. */
57 exp_print_token (token_code_type code
, int infix_p
)
91 { SECTIONS
, "SECTIONS" },
92 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
94 { DEFINED
, "DEFINED" },
95 { TARGET_K
, "TARGET" },
96 { SEARCH_DIR
, "SEARCH_DIR" },
100 { ALIGNOF
, "ALIGNOF" },
101 { SIZEOF
, "SIZEOF" },
103 { LOADADDR
, "LOADADDR" },
104 { CONSTANT
, "CONSTANT" },
105 { ABSOLUTE
, "ABSOLUTE" },
108 { ASSERT_K
, "ASSERT" },
109 { REL
, "relocatable" },
110 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
111 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
112 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
113 { ORIGIN
, "ORIGIN" },
114 { LENGTH
, "LENGTH" },
115 { SEGMENT_START
, "SEGMENT_START" }
119 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
120 if (table
[idx
].code
== code
)
124 fputc (' ', config
.map_file
);
126 if (idx
< ARRAY_SIZE (table
))
127 fputs (table
[idx
].name
, config
.map_file
);
129 fputc (code
, config
.map_file
);
131 fprintf (config
.map_file
, "<code %d>", code
);
134 fputc (' ', config
.map_file
);
140 if (expld
.result
.section
!= NULL
)
141 expld
.result
.value
+= expld
.result
.section
->vma
;
142 expld
.result
.section
= bfd_abs_section_ptr
;
146 new_abs (bfd_vma value
)
148 expld
.result
.valid_p
= TRUE
;
149 expld
.result
.section
= bfd_abs_section_ptr
;
150 expld
.result
.value
= value
;
151 expld
.result
.str
= NULL
;
155 exp_intop (bfd_vma value
)
157 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
158 new_e
->type
.node_code
= INT
;
159 new_e
->type
.lineno
= lineno
;
160 new_e
->value
.value
= value
;
161 new_e
->value
.str
= NULL
;
162 new_e
->type
.node_class
= etree_value
;
167 exp_bigintop (bfd_vma value
, char *str
)
169 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->value
));
170 new_e
->type
.node_code
= INT
;
171 new_e
->type
.lineno
= lineno
;
172 new_e
->value
.value
= value
;
173 new_e
->value
.str
= str
;
174 new_e
->type
.node_class
= etree_value
;
178 /* Build an expression representing an unnamed relocatable value. */
181 exp_relop (asection
*section
, bfd_vma value
)
183 etree_type
*new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->rel
));
184 new_e
->type
.node_code
= REL
;
185 new_e
->type
.lineno
= lineno
;
186 new_e
->type
.node_class
= etree_rel
;
187 new_e
->rel
.section
= section
;
188 new_e
->rel
.value
= value
;
193 new_number (bfd_vma value
)
195 expld
.result
.valid_p
= TRUE
;
196 expld
.result
.value
= value
;
197 expld
.result
.str
= NULL
;
198 expld
.result
.section
= NULL
;
202 new_rel (bfd_vma value
, asection
*section
)
204 expld
.result
.valid_p
= TRUE
;
205 expld
.result
.value
= value
;
206 expld
.result
.str
= NULL
;
207 expld
.result
.section
= section
;
211 new_rel_from_abs (bfd_vma value
)
213 expld
.result
.valid_p
= TRUE
;
214 expld
.result
.value
= value
- expld
.section
->vma
;
215 expld
.result
.str
= NULL
;
216 expld
.result
.section
= expld
.section
;
220 fold_unary (etree_type
*tree
)
222 exp_fold_tree_1 (tree
->unary
.child
);
223 if (expld
.result
.valid_p
)
225 switch (tree
->type
.node_code
)
228 if (expld
.phase
!= lang_first_phase_enum
)
229 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
231 expld
.result
.valid_p
= FALSE
;
239 expld
.result
.value
= ~expld
.result
.value
;
243 expld
.result
.value
= !expld
.result
.value
;
247 expld
.result
.value
= -expld
.result
.value
;
251 /* Return next place aligned to value. */
252 if (expld
.phase
!= lang_first_phase_enum
)
255 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
258 expld
.result
.valid_p
= FALSE
;
261 case DATA_SEGMENT_END
:
262 if (expld
.phase
== lang_first_phase_enum
263 || expld
.section
!= bfd_abs_section_ptr
)
265 expld
.result
.valid_p
= FALSE
;
267 else if (expld
.dataseg
.phase
== exp_dataseg_align_seen
268 || expld
.dataseg
.phase
== exp_dataseg_relro_seen
)
270 expld
.dataseg
.phase
= exp_dataseg_end_seen
;
271 expld
.dataseg
.end
= expld
.result
.value
;
273 else if (expld
.dataseg
.phase
== exp_dataseg_done
274 || expld
.dataseg
.phase
== exp_dataseg_adjust
275 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
280 expld
.result
.valid_p
= FALSE
;
291 fold_binary (etree_type
*tree
)
293 etree_value_type lhs
;
294 exp_fold_tree_1 (tree
->binary
.lhs
);
296 /* The SEGMENT_START operator is special because its first
297 operand is a string, not the name of a symbol. Note that the
298 operands have been swapped, so binary.lhs is second (default)
299 operand, binary.rhs is first operand. */
300 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
302 const char *segment_name
;
305 /* Check to see if the user has overridden the default
307 segment_name
= tree
->binary
.rhs
->name
.name
;
308 for (seg
= segments
; seg
; seg
= seg
->next
)
309 if (strcmp (seg
->name
, segment_name
) == 0)
312 && config
.magic_demand_paged
313 && (seg
->value
% config
.maxpagesize
) != 0)
314 einfo (_("%P: warning: address of `%s' isn't multiple of maximum page size\n"),
317 new_rel_from_abs (seg
->value
);
324 exp_fold_tree_1 (tree
->binary
.rhs
);
325 expld
.result
.valid_p
&= lhs
.valid_p
;
327 if (expld
.result
.valid_p
)
329 if (lhs
.section
!= expld
.result
.section
)
331 /* If the values are from different sections, and neither is
332 just a number, make both the source arguments absolute. */
333 if (expld
.result
.section
!= NULL
334 && lhs
.section
!= NULL
)
337 lhs
.value
+= lhs
.section
->vma
;
340 /* If the rhs is just a number, keep the lhs section. */
341 else if (expld
.result
.section
== NULL
)
342 expld
.result
.section
= lhs
.section
;
345 switch (tree
->type
.node_code
)
348 if (expld
.result
.value
!= 0)
349 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
350 % (bfd_signed_vma
) expld
.result
.value
);
351 else if (expld
.phase
!= lang_mark_phase_enum
)
352 einfo (_("%F%S %% by zero\n"));
356 if (expld
.result
.value
!= 0)
357 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
358 / (bfd_signed_vma
) expld
.result
.value
);
359 else if (expld
.phase
!= lang_mark_phase_enum
)
360 einfo (_("%F%S / by zero\n"));
365 expld.result.value = lhs.value y expld.result.value; \
370 expld.result.value = lhs.value y expld.result.value; \
371 expld.result.section = NULL; \
392 if (lhs
.value
> expld
.result
.value
)
393 expld
.result
.value
= lhs
.value
;
397 if (lhs
.value
< expld
.result
.value
)
398 expld
.result
.value
= lhs
.value
;
402 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
405 case DATA_SEGMENT_ALIGN
:
406 expld
.dataseg
.relro
= exp_dataseg_relro_start
;
407 if (expld
.phase
== lang_first_phase_enum
408 || expld
.section
!= bfd_abs_section_ptr
)
409 expld
.result
.valid_p
= FALSE
;
412 bfd_vma maxpage
= lhs
.value
;
413 bfd_vma commonpage
= expld
.result
.value
;
415 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
416 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
417 expld
.result
.value
= expld
.dataseg
.base
;
418 else if (expld
.dataseg
.phase
== exp_dataseg_adjust
)
420 if (commonpage
< maxpage
)
421 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
422 & (maxpage
- commonpage
));
426 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
427 if (expld
.dataseg
.phase
== exp_dataseg_done
)
431 else if (expld
.dataseg
.phase
== exp_dataseg_none
)
433 expld
.dataseg
.phase
= exp_dataseg_align_seen
;
434 expld
.dataseg
.min_base
= expld
.dot
;
435 expld
.dataseg
.base
= expld
.result
.value
;
436 expld
.dataseg
.pagesize
= commonpage
;
437 expld
.dataseg
.maxpagesize
= maxpage
;
438 expld
.dataseg
.relro_end
= 0;
441 expld
.result
.valid_p
= FALSE
;
446 case DATA_SEGMENT_RELRO_END
:
447 expld
.dataseg
.relro
= exp_dataseg_relro_end
;
448 if (expld
.phase
== lang_first_phase_enum
449 || expld
.section
!= bfd_abs_section_ptr
)
450 expld
.result
.valid_p
= FALSE
;
451 else if (expld
.dataseg
.phase
== exp_dataseg_align_seen
452 || expld
.dataseg
.phase
== exp_dataseg_adjust
453 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
454 || expld
.dataseg
.phase
== exp_dataseg_done
)
456 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
457 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
458 expld
.dataseg
.relro_end
= lhs
.value
+ expld
.result
.value
;
460 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
461 && (expld
.dataseg
.relro_end
462 & (expld
.dataseg
.pagesize
- 1)))
464 expld
.dataseg
.relro_end
+= expld
.dataseg
.pagesize
- 1;
465 expld
.dataseg
.relro_end
&= ~(expld
.dataseg
.pagesize
- 1);
466 expld
.result
.value
= (expld
.dataseg
.relro_end
467 - expld
.result
.value
);
470 expld
.result
.value
= lhs
.value
;
472 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
)
473 expld
.dataseg
.phase
= exp_dataseg_relro_seen
;
476 expld
.result
.valid_p
= FALSE
;
486 fold_trinary (etree_type
*tree
)
488 exp_fold_tree_1 (tree
->trinary
.cond
);
489 if (expld
.result
.valid_p
)
490 exp_fold_tree_1 (expld
.result
.value
492 : tree
->trinary
.rhs
);
496 fold_name (etree_type
*tree
)
498 memset (&expld
.result
, 0, sizeof (expld
.result
));
500 switch (tree
->type
.node_code
)
503 if (expld
.phase
!= lang_first_phase_enum
)
505 bfd_vma hdr_size
= 0;
506 /* Don't find the real header size if only marking sections;
507 The bfd function may cache incorrect data. */
508 if (expld
.phase
!= lang_mark_phase_enum
)
509 hdr_size
= bfd_sizeof_headers (link_info
.output_bfd
, &link_info
);
510 new_number (hdr_size
);
515 expld
.uses_defined
= TRUE
;
516 if (expld
.phase
== lang_first_phase_enum
)
517 lang_track_definedness (tree
->name
.name
);
520 struct bfd_link_hash_entry
*h
;
522 = lang_symbol_definition_iteration (tree
->name
.name
);
524 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
528 new_number (h
!= NULL
529 && (h
->type
== bfd_link_hash_defined
530 || h
->type
== bfd_link_hash_defweak
531 || h
->type
== bfd_link_hash_common
)
532 && (def_iteration
== lang_statement_iteration
533 || def_iteration
== -1));
538 if (expld
.phase
== lang_first_phase_enum
)
540 else if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
541 new_rel_from_abs (expld
.dot
);
544 struct bfd_link_hash_entry
*h
;
546 h
= bfd_wrapped_link_hash_lookup (link_info
.output_bfd
,
551 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
552 else if (h
->type
== bfd_link_hash_defined
553 || h
->type
== bfd_link_hash_defweak
)
555 asection
*output_section
;
557 output_section
= h
->u
.def
.section
->output_section
;
558 if (output_section
== NULL
)
560 if (expld
.phase
!= lang_mark_phase_enum
)
561 einfo (_("%X%S: unresolvable symbol `%s'"
562 " referenced in expression\n"),
565 else if (output_section
== bfd_abs_section_ptr
566 && (expld
.section
!= bfd_abs_section_ptr
567 || ld_compatibility
>= 221))
568 new_number (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
);
570 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
573 else if (expld
.phase
== lang_final_phase_enum
574 || expld
.assigning_to_dot
)
575 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
577 else if (h
->type
== bfd_link_hash_new
)
579 h
->type
= bfd_link_hash_undefined
;
580 h
->u
.undef
.abfd
= NULL
;
581 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
582 bfd_link_add_undef (link_info
.hash
, h
);
588 if (expld
.phase
!= lang_first_phase_enum
)
590 lang_output_section_statement_type
*os
;
592 os
= lang_output_section_find (tree
->name
.name
);
595 if (expld
.phase
== lang_final_phase_enum
)
596 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
599 else if (os
->processed_vma
)
600 new_rel (0, os
->bfd_section
);
605 if (expld
.phase
!= lang_first_phase_enum
)
607 lang_output_section_statement_type
*os
;
609 os
= lang_output_section_find (tree
->name
.name
);
612 if (expld
.phase
== lang_final_phase_enum
)
613 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
616 else if (os
->processed_lma
)
618 if (os
->load_base
== NULL
)
619 new_abs (os
->bfd_section
->lma
);
622 exp_fold_tree_1 (os
->load_base
);
623 if (expld
.result
.valid_p
)
632 if (expld
.phase
!= lang_first_phase_enum
)
634 lang_output_section_statement_type
*os
;
636 os
= lang_output_section_find (tree
->name
.name
);
639 if (expld
.phase
== lang_final_phase_enum
)
640 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
644 else if (os
->processed_vma
)
648 if (tree
->type
.node_code
== SIZEOF
)
649 val
= (os
->bfd_section
->size
650 / bfd_octets_per_byte (link_info
.output_bfd
));
652 val
= (bfd_vma
)1 << os
->bfd_section
->alignment_power
;
661 lang_memory_region_type
*mem
;
663 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
665 new_number (mem
->length
);
667 einfo (_("%F%S: undefined MEMORY region `%s'"
668 " referenced in expression\n"), tree
->name
.name
);
673 if (expld
.phase
!= lang_first_phase_enum
)
675 lang_memory_region_type
*mem
;
677 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
679 new_rel_from_abs (mem
->origin
);
681 einfo (_("%F%S: undefined MEMORY region `%s'"
682 " referenced in expression\n"), tree
->name
.name
);
687 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
688 new_number (config
.maxpagesize
);
689 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
690 new_number (config
.commonpagesize
);
692 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
703 exp_fold_tree_1 (etree_type
*tree
)
707 memset (&expld
.result
, 0, sizeof (expld
.result
));
711 switch (tree
->type
.node_class
)
714 if (expld
.section
== bfd_abs_section_ptr
715 && ld_compatibility
< 221)
716 new_abs (tree
->value
.value
);
718 new_number (tree
->value
.value
);
719 expld
.result
.str
= tree
->value
.str
;
723 if (expld
.phase
!= lang_first_phase_enum
)
725 asection
*output_section
= tree
->rel
.section
->output_section
;
726 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
730 memset (&expld
.result
, 0, sizeof (expld
.result
));
734 exp_fold_tree_1 (tree
->assert_s
.child
);
735 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
736 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
754 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
756 /* Assignment to dot can only be done during allocation. */
757 if (tree
->type
.node_class
!= etree_assign
)
758 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
759 if (expld
.phase
== lang_mark_phase_enum
760 || expld
.phase
== lang_allocating_phase_enum
761 || (expld
.phase
== lang_final_phase_enum
762 && expld
.section
== bfd_abs_section_ptr
))
764 /* Notify the folder that this is an assignment to dot. */
765 expld
.assigning_to_dot
= TRUE
;
766 exp_fold_tree_1 (tree
->assign
.src
);
767 expld
.assigning_to_dot
= FALSE
;
769 if (!expld
.result
.valid_p
)
771 if (expld
.phase
!= lang_mark_phase_enum
)
772 einfo (_("%F%S invalid assignment to location counter\n"));
774 else if (expld
.dotp
== NULL
)
775 einfo (_("%F%S assignment to location counter"
776 " invalid outside of SECTION\n"));
781 nextdot
= expld
.result
.value
;
782 if (expld
.result
.section
!= NULL
)
783 nextdot
+= expld
.result
.section
->vma
;
785 nextdot
+= expld
.section
->vma
;
786 if (nextdot
< expld
.dot
787 && expld
.section
!= bfd_abs_section_ptr
)
788 einfo (_("%F%S cannot move location counter backwards"
789 " (from %V to %V)\n"), expld
.dot
, nextdot
);
793 *expld
.dotp
= nextdot
;
798 memset (&expld
.result
, 0, sizeof (expld
.result
));
802 struct bfd_link_hash_entry
*h
= NULL
;
804 if (tree
->type
.node_class
== etree_provide
)
806 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
809 || (h
->type
!= bfd_link_hash_new
810 && h
->type
!= bfd_link_hash_undefined
811 && h
->type
!= bfd_link_hash_common
))
813 /* Do nothing. The symbol was never referenced, or was
814 defined by some object. */
819 exp_fold_tree_1 (tree
->assign
.src
);
820 if (expld
.result
.valid_p
821 || (expld
.phase
== lang_first_phase_enum
822 && !expld
.uses_defined
))
826 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
829 einfo (_("%P%F:%s: hash creation failed\n"),
833 /* FIXME: Should we worry if the symbol is already
835 lang_update_definedness (tree
->assign
.dst
, h
);
836 h
->type
= bfd_link_hash_defined
;
837 h
->u
.def
.value
= expld
.result
.value
;
838 if (expld
.result
.section
== NULL
)
839 expld
.result
.section
= expld
.section
;
840 h
->u
.def
.section
= expld
.result
.section
;
841 if (tree
->type
.node_class
== etree_provide
)
842 tree
->type
.node_class
= etree_provided
;
844 /* Copy the symbol type if this is a simple assignment of
845 one symbol to annother. */
846 if (tree
->assign
.src
->type
.node_class
== etree_name
)
848 struct bfd_link_hash_entry
*hsrc
;
850 hsrc
= bfd_link_hash_lookup (link_info
.hash
,
851 tree
->assign
.src
->name
.name
,
854 bfd_copy_link_hash_symbol_type (link_info
.output_bfd
, h
,
858 else if (expld
.phase
== lang_final_phase_enum
)
860 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
863 && h
->type
== bfd_link_hash_new
)
864 h
->type
= bfd_link_hash_undefined
;
875 memset (&expld
.result
, 0, sizeof (expld
.result
));
881 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
885 expld
.section
= current_section
;
886 expld
.uses_defined
= FALSE
;
887 exp_fold_tree_1 (tree
);
891 exp_fold_tree_no_dot (etree_type
*tree
)
895 expld
.section
= bfd_abs_section_ptr
;
896 expld
.uses_defined
= FALSE
;
897 exp_fold_tree_1 (tree
);
901 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
903 etree_type value
, *new_e
;
905 value
.type
.node_code
= code
;
906 value
.type
.lineno
= lhs
->type
.lineno
;
907 value
.binary
.lhs
= lhs
;
908 value
.binary
.rhs
= rhs
;
909 value
.type
.node_class
= etree_binary
;
910 exp_fold_tree_no_dot (&value
);
911 if (expld
.result
.valid_p
)
912 return exp_intop (expld
.result
.value
);
914 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->binary
));
915 memcpy (new_e
, &value
, sizeof (new_e
->binary
));
920 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
922 etree_type value
, *new_e
;
924 value
.type
.node_code
= code
;
925 value
.type
.lineno
= lhs
->type
.lineno
;
926 value
.trinary
.lhs
= lhs
;
927 value
.trinary
.cond
= cond
;
928 value
.trinary
.rhs
= rhs
;
929 value
.type
.node_class
= etree_trinary
;
930 exp_fold_tree_no_dot (&value
);
931 if (expld
.result
.valid_p
)
932 return exp_intop (expld
.result
.value
);
934 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->trinary
));
935 memcpy (new_e
, &value
, sizeof (new_e
->trinary
));
940 exp_unop (int code
, etree_type
*child
)
942 etree_type value
, *new_e
;
944 value
.unary
.type
.node_code
= code
;
945 value
.unary
.type
.lineno
= child
->type
.lineno
;
946 value
.unary
.child
= child
;
947 value
.unary
.type
.node_class
= etree_unary
;
948 exp_fold_tree_no_dot (&value
);
949 if (expld
.result
.valid_p
)
950 return exp_intop (expld
.result
.value
);
952 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->unary
));
953 memcpy (new_e
, &value
, sizeof (new_e
->unary
));
958 exp_nameop (int code
, const char *name
)
960 etree_type value
, *new_e
;
962 value
.name
.type
.node_code
= code
;
963 value
.name
.type
.lineno
= lineno
;
964 value
.name
.name
= name
;
965 value
.name
.type
.node_class
= etree_name
;
967 exp_fold_tree_no_dot (&value
);
968 if (expld
.result
.valid_p
)
969 return exp_intop (expld
.result
.value
);
971 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->name
));
972 memcpy (new_e
, &value
, sizeof (new_e
->name
));
978 exp_assop (int code
, const char *dst
, etree_type
*src
)
982 new_e
= (etree_type
*) stat_alloc (sizeof (new_e
->assign
));
983 new_e
->type
.node_code
= code
;
984 new_e
->type
.lineno
= src
->type
.lineno
;
985 new_e
->type
.node_class
= etree_assign
;
986 new_e
->assign
.src
= src
;
987 new_e
->assign
.dst
= dst
;
991 /* Handle PROVIDE. */
994 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
998 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
999 n
->assign
.type
.node_code
= '=';
1000 n
->assign
.type
.lineno
= src
->type
.lineno
;
1001 n
->assign
.type
.node_class
= etree_provide
;
1002 n
->assign
.src
= src
;
1003 n
->assign
.dst
= dst
;
1004 n
->assign
.hidden
= hidden
;
1008 /* Handle ASSERT. */
1011 exp_assert (etree_type
*exp
, const char *message
)
1015 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
1016 n
->assert_s
.type
.node_code
= '!';
1017 n
->assert_s
.type
.lineno
= exp
->type
.lineno
;
1018 n
->assert_s
.type
.node_class
= etree_assert
;
1019 n
->assert_s
.child
= exp
;
1020 n
->assert_s
.message
= message
;
1025 exp_print_tree (etree_type
*tree
)
1027 bfd_boolean function_like
;
1029 if (config
.map_file
== NULL
)
1030 config
.map_file
= stderr
;
1034 minfo ("NULL TREE\n");
1038 switch (tree
->type
.node_class
)
1041 minfo ("0x%v", tree
->value
.value
);
1044 if (tree
->rel
.section
->owner
!= NULL
)
1045 minfo ("%B:", tree
->rel
.section
->owner
);
1046 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
1049 fputs (tree
->assign
.dst
, config
.map_file
);
1050 exp_print_token (tree
->type
.node_code
, TRUE
);
1051 exp_print_tree (tree
->assign
.src
);
1054 case etree_provided
:
1055 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
1056 exp_print_tree (tree
->assign
.src
);
1057 fputc (')', config
.map_file
);
1060 function_like
= FALSE
;
1061 switch (tree
->type
.node_code
)
1066 case DATA_SEGMENT_ALIGN
:
1067 case DATA_SEGMENT_RELRO_END
:
1068 function_like
= TRUE
;
1072 exp_print_token (tree
->type
.node_code
, FALSE
);
1073 fputc (' ', config
.map_file
);
1075 fputc ('(', config
.map_file
);
1076 exp_print_tree (tree
->binary
.lhs
);
1078 fprintf (config
.map_file
, ", ");
1080 exp_print_token (tree
->type
.node_code
, TRUE
);
1081 exp_print_tree (tree
->binary
.rhs
);
1082 fputc (')', config
.map_file
);
1085 exp_print_tree (tree
->trinary
.cond
);
1086 fputc ('?', config
.map_file
);
1087 exp_print_tree (tree
->trinary
.lhs
);
1088 fputc (':', config
.map_file
);
1089 exp_print_tree (tree
->trinary
.rhs
);
1092 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
1093 if (tree
->unary
.child
)
1095 fprintf (config
.map_file
, " (");
1096 exp_print_tree (tree
->unary
.child
);
1097 fputc (')', config
.map_file
);
1102 fprintf (config
.map_file
, "ASSERT (");
1103 exp_print_tree (tree
->assert_s
.child
);
1104 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
1108 if (tree
->type
.node_code
== NAME
)
1109 fputs (tree
->name
.name
, config
.map_file
);
1112 exp_print_token (tree
->type
.node_code
, FALSE
);
1113 if (tree
->name
.name
)
1114 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1124 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1128 exp_fold_tree_no_dot (tree
);
1129 if (expld
.result
.valid_p
)
1130 return expld
.result
.value
;
1131 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1132 einfo (_("%F%S: nonconstant expression for %s\n"), name
);
1138 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1140 return exp_get_vma (tree
, def
, name
);
1144 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1153 exp_fold_tree_no_dot (tree
);
1154 if (!expld
.result
.valid_p
)
1156 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1157 einfo (_("%F%S: nonconstant expression for %s\n"), name
);
1161 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1165 fill
= (fill_type
*) xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1166 fill
->size
= (len
+ 1) / 2;
1168 s
= (unsigned char *) expld
.result
.str
;
1176 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1190 fill
= (fill_type
*) xmalloc (4 + sizeof (*fill
) - 1);
1191 val
= expld
.result
.value
;
1192 fill
->data
[0] = (val
>> 24) & 0xff;
1193 fill
->data
[1] = (val
>> 16) & 0xff;
1194 fill
->data
[2] = (val
>> 8) & 0xff;
1195 fill
->data
[3] = (val
>> 0) & 0xff;
1202 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1206 exp_fold_tree_no_dot (tree
);
1208 if (expld
.result
.valid_p
)
1210 if (expld
.result
.section
!= NULL
)
1211 expld
.result
.value
+= expld
.result
.section
->vma
;
1212 return expld
.result
.value
;
1214 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1216 lineno
= tree
->type
.lineno
;
1217 einfo (_("%F%S: nonconstant expression for %s\n"), name
);
1224 align_n (bfd_vma value
, bfd_vma align
)
1229 value
= (value
+ align
- 1) / align
;
1230 return value
* align
;