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
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
7 This file is part of GLD, the Gnu Linker.
9 GLD 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 2, or (at your option)
14 GLD 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 GLD; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 /* This module is in charge of working out the contents of expressions.
26 It has to keep track of the relative/absness of a symbol etc. This
27 is done by keeping all values in a struct (an etree_value_type)
28 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 void exp_fold_tree_no_dot (etree_type
*);
46 static bfd_vma
align_n (bfd_vma
, bfd_vma
);
48 segment_type
*segments
;
50 struct ldexp_control expld
;
52 /* Print the string representation of the given token. Surround it
53 with spaces if INFIX_P is TRUE. */
56 exp_print_token (token_code_type code
, int infix_p
)
90 { SECTIONS
, "SECTIONS" },
91 { SIZEOF_HEADERS
, "SIZEOF_HEADERS" },
93 { DEFINED
, "DEFINED" },
94 { TARGET_K
, "TARGET" },
95 { SEARCH_DIR
, "SEARCH_DIR" },
101 { LOADADDR
, "LOADADDR" },
102 { CONSTANT
, "CONSTANT" },
104 { REL
, "relocatable" },
105 { DATA_SEGMENT_ALIGN
, "DATA_SEGMENT_ALIGN" },
106 { DATA_SEGMENT_RELRO_END
, "DATA_SEGMENT_RELRO_END" },
107 { DATA_SEGMENT_END
, "DATA_SEGMENT_END" },
108 { ORIGIN
, "ORIGIN" },
109 { LENGTH
, "LENGTH" },
110 { SEGMENT_START
, "SEGMENT_START" }
114 for (idx
= 0; idx
< ARRAY_SIZE (table
); idx
++)
115 if (table
[idx
].code
== code
)
119 fputc (' ', config
.map_file
);
121 if (idx
< ARRAY_SIZE (table
))
122 fputs (table
[idx
].name
, config
.map_file
);
124 fputc (code
, config
.map_file
);
126 fprintf (config
.map_file
, "<code %d>", code
);
129 fputc (' ', config
.map_file
);
135 expld
.result
.value
+= expld
.result
.section
->vma
;
136 expld
.result
.section
= bfd_abs_section_ptr
;
140 new_abs (bfd_vma value
)
142 expld
.result
.valid_p
= TRUE
;
143 expld
.result
.section
= bfd_abs_section_ptr
;
144 expld
.result
.value
= value
;
145 expld
.result
.str
= NULL
;
149 exp_intop (bfd_vma value
)
151 etree_type
*new = stat_alloc (sizeof (new->value
));
152 new->type
.node_code
= INT
;
153 new->value
.value
= value
;
154 new->value
.str
= NULL
;
155 new->type
.node_class
= etree_value
;
160 exp_bigintop (bfd_vma value
, char *str
)
162 etree_type
*new = stat_alloc (sizeof (new->value
));
163 new->type
.node_code
= INT
;
164 new->value
.value
= value
;
165 new->value
.str
= str
;
166 new->type
.node_class
= etree_value
;
170 /* Build an expression representing an unnamed relocatable value. */
173 exp_relop (asection
*section
, bfd_vma value
)
175 etree_type
*new = stat_alloc (sizeof (new->rel
));
176 new->type
.node_code
= REL
;
177 new->type
.node_class
= etree_rel
;
178 new->rel
.section
= section
;
179 new->rel
.value
= value
;
184 new_rel (bfd_vma value
, char *str
, asection
*section
)
186 expld
.result
.valid_p
= TRUE
;
187 expld
.result
.value
= value
;
188 expld
.result
.str
= str
;
189 expld
.result
.section
= section
;
193 new_rel_from_abs (bfd_vma value
)
195 expld
.result
.valid_p
= TRUE
;
196 expld
.result
.value
= value
- expld
.section
->vma
;
197 expld
.result
.str
= NULL
;
198 expld
.result
.section
= expld
.section
;
202 fold_unary (etree_type
*tree
)
204 exp_fold_tree_1 (tree
->unary
.child
);
205 if (expld
.result
.valid_p
)
207 switch (tree
->type
.node_code
)
210 if (expld
.phase
!= lang_first_phase_enum
)
211 new_rel_from_abs (align_n (expld
.dot
, expld
.result
.value
));
213 expld
.result
.valid_p
= FALSE
;
222 expld
.result
.value
= ~expld
.result
.value
;
227 expld
.result
.value
= !expld
.result
.value
;
232 expld
.result
.value
= -expld
.result
.value
;
236 /* Return next place aligned to value. */
237 if (expld
.phase
!= lang_first_phase_enum
)
240 expld
.result
.value
= align_n (expld
.dot
, expld
.result
.value
);
243 expld
.result
.valid_p
= FALSE
;
246 case DATA_SEGMENT_END
:
247 if (expld
.phase
!= lang_first_phase_enum
248 && expld
.section
== bfd_abs_section_ptr
249 && (expld
.dataseg
.phase
== exp_dataseg_align_seen
250 || expld
.dataseg
.phase
== exp_dataseg_relro_seen
251 || expld
.dataseg
.phase
== exp_dataseg_adjust
252 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
253 || expld
.phase
== lang_final_phase_enum
))
255 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
256 || expld
.dataseg
.phase
== exp_dataseg_relro_seen
)
258 expld
.dataseg
.phase
= exp_dataseg_end_seen
;
259 expld
.dataseg
.end
= expld
.result
.value
;
263 expld
.result
.valid_p
= FALSE
;
274 fold_binary (etree_type
*tree
)
276 exp_fold_tree_1 (tree
->binary
.lhs
);
278 /* The SEGMENT_START operator is special because its first
279 operand is a string, not the name of a symbol. */
280 if (expld
.result
.valid_p
&& tree
->type
.node_code
== SEGMENT_START
)
282 const char *segment_name
;
284 /* Check to see if the user has overridden the default
286 segment_name
= tree
->binary
.rhs
->name
.name
;
287 for (seg
= segments
; seg
; seg
= seg
->next
)
288 if (strcmp (seg
->name
, segment_name
) == 0)
291 expld
.result
.value
= seg
->value
;
292 expld
.result
.str
= NULL
;
293 expld
.result
.section
= NULL
;
297 else if (expld
.result
.valid_p
)
299 etree_value_type lhs
= expld
.result
;
301 exp_fold_tree_1 (tree
->binary
.rhs
);
302 if (expld
.result
.valid_p
)
304 /* If the values are from different sections, or this is an
305 absolute expression, make both the source arguments
306 absolute. However, adding or subtracting an absolute
307 value from a relative value is meaningful, and is an
309 if (expld
.section
!= bfd_abs_section_ptr
310 && lhs
.section
== bfd_abs_section_ptr
311 && tree
->type
.node_code
== '+')
313 /* Keep the section of the rhs term. */
314 expld
.result
.value
= lhs
.value
+ expld
.result
.value
;
317 else if (expld
.section
!= bfd_abs_section_ptr
318 && expld
.result
.section
== bfd_abs_section_ptr
319 && (tree
->type
.node_code
== '+'
320 || tree
->type
.node_code
== '-'))
322 /* Keep the section of the lhs term. */
323 expld
.result
.section
= lhs
.section
;
325 else if (expld
.result
.section
!= lhs
.section
326 || expld
.section
== bfd_abs_section_ptr
)
329 lhs
.value
+= lhs
.section
->vma
;
332 switch (tree
->type
.node_code
)
335 if (expld
.result
.value
!= 0)
336 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
337 % (bfd_signed_vma
) expld
.result
.value
);
338 else if (expld
.phase
!= lang_mark_phase_enum
)
339 einfo (_("%F%S %% by zero\n"));
343 if (expld
.result
.value
!= 0)
344 expld
.result
.value
= ((bfd_signed_vma
) lhs
.value
345 / (bfd_signed_vma
) expld
.result
.value
);
346 else if (expld
.phase
!= lang_mark_phase_enum
)
347 einfo (_("%F%S / by zero\n"));
352 expld.result.value = lhs.value y expld.result.value; \
373 if (lhs
.value
> expld
.result
.value
)
374 expld
.result
.value
= lhs
.value
;
378 if (lhs
.value
< expld
.result
.value
)
379 expld
.result
.value
= lhs
.value
;
383 expld
.result
.value
= align_n (lhs
.value
, expld
.result
.value
);
386 case DATA_SEGMENT_ALIGN
:
387 if (expld
.phase
!= lang_first_phase_enum
388 && expld
.section
== bfd_abs_section_ptr
389 && (expld
.dataseg
.phase
== exp_dataseg_none
390 || expld
.dataseg
.phase
== exp_dataseg_adjust
391 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
392 || expld
.phase
== lang_final_phase_enum
))
394 bfd_vma maxpage
= lhs
.value
;
395 bfd_vma commonpage
= expld
.result
.value
;
397 expld
.result
.value
= align_n (expld
.dot
, maxpage
);
398 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
399 expld
.result
.value
= expld
.dataseg
.base
;
400 else if (expld
.dataseg
.phase
!= exp_dataseg_adjust
)
402 expld
.result
.value
+= expld
.dot
& (maxpage
- 1);
403 if (expld
.phase
== lang_allocating_phase_enum
)
405 expld
.dataseg
.phase
= exp_dataseg_align_seen
;
406 expld
.dataseg
.min_base
= align_n (expld
.dot
, maxpage
);
407 expld
.dataseg
.base
= expld
.result
.value
;
408 expld
.dataseg
.pagesize
= commonpage
;
409 expld
.dataseg
.maxpagesize
= maxpage
;
410 expld
.dataseg
.relro_end
= 0;
413 else if (commonpage
< maxpage
)
414 expld
.result
.value
+= ((expld
.dot
+ commonpage
- 1)
415 & (maxpage
- commonpage
));
418 expld
.result
.valid_p
= FALSE
;
421 case DATA_SEGMENT_RELRO_END
:
422 if (expld
.phase
!= lang_first_phase_enum
423 && (expld
.dataseg
.phase
== exp_dataseg_align_seen
424 || expld
.dataseg
.phase
== exp_dataseg_adjust
425 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
426 || expld
.phase
== lang_final_phase_enum
))
428 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
429 || expld
.dataseg
.phase
== exp_dataseg_relro_adjust
)
430 expld
.dataseg
.relro_end
= lhs
.value
+ expld
.result
.value
;
432 if (expld
.dataseg
.phase
== exp_dataseg_relro_adjust
433 && (expld
.dataseg
.relro_end
434 & (expld
.dataseg
.pagesize
- 1)))
436 expld
.dataseg
.relro_end
+= expld
.dataseg
.pagesize
- 1;
437 expld
.dataseg
.relro_end
&= ~(expld
.dataseg
.pagesize
- 1);
438 expld
.result
.value
= (expld
.dataseg
.relro_end
439 - expld
.result
.value
);
442 expld
.result
.value
= lhs
.value
;
444 if (expld
.dataseg
.phase
== exp_dataseg_align_seen
)
445 expld
.dataseg
.phase
= exp_dataseg_relro_seen
;
448 expld
.result
.valid_p
= FALSE
;
456 expld
.result
.valid_p
= FALSE
;
461 fold_trinary (etree_type
*tree
)
463 exp_fold_tree_1 (tree
->trinary
.cond
);
464 if (expld
.result
.valid_p
)
465 exp_fold_tree_1 (expld
.result
.value
467 : tree
->trinary
.rhs
);
471 fold_name (etree_type
*tree
)
473 memset (&expld
.result
, 0, sizeof (expld
.result
));
475 switch (tree
->type
.node_code
)
478 if (expld
.phase
!= lang_first_phase_enum
)
480 bfd_vma hdr_size
= 0;
481 /* Don't find the real header size if only marking sections;
482 The bfd function may cache incorrect data. */
483 if (expld
.phase
!= lang_mark_phase_enum
)
484 hdr_size
= bfd_sizeof_headers (output_bfd
, &link_info
);
489 if (expld
.phase
== lang_first_phase_enum
)
490 lang_track_definedness (tree
->name
.name
);
493 struct bfd_link_hash_entry
*h
;
495 = lang_symbol_definition_iteration (tree
->name
.name
);
497 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
500 expld
.result
.value
= (h
!= NULL
501 && (h
->type
== bfd_link_hash_defined
502 || h
->type
== bfd_link_hash_defweak
503 || h
->type
== bfd_link_hash_common
)
504 && (def_iteration
== lang_statement_iteration
505 || def_iteration
== -1));
506 expld
.result
.section
= bfd_abs_section_ptr
;
507 expld
.result
.valid_p
= TRUE
;
511 if (expld
.phase
== lang_first_phase_enum
)
513 else if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
514 new_rel_from_abs (expld
.dot
);
517 struct bfd_link_hash_entry
*h
;
519 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
523 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
524 else if (h
->type
== bfd_link_hash_defined
525 || h
->type
== bfd_link_hash_defweak
)
527 if (bfd_is_abs_section (h
->u
.def
.section
))
528 new_abs (h
->u
.def
.value
);
531 asection
*output_section
;
533 output_section
= h
->u
.def
.section
->output_section
;
534 if (output_section
== NULL
)
536 if (expld
.phase
!= lang_mark_phase_enum
)
537 einfo (_("%X%S: unresolvable symbol `%s'"
538 " referenced in expression\n"),
542 new_rel (h
->u
.def
.value
+ h
->u
.def
.section
->output_offset
,
543 NULL
, output_section
);
546 else if (expld
.phase
== lang_final_phase_enum
547 || expld
.assigning_to_dot
)
548 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
550 else if (h
->type
== bfd_link_hash_new
)
552 h
->type
= bfd_link_hash_undefined
;
553 h
->u
.undef
.abfd
= NULL
;
554 if (h
->u
.undef
.next
== NULL
&& h
!= link_info
.hash
->undefs_tail
)
555 bfd_link_add_undef (link_info
.hash
, h
);
561 if (expld
.phase
!= lang_first_phase_enum
)
563 lang_output_section_statement_type
*os
;
565 os
= lang_output_section_find (tree
->name
.name
);
566 if (os
!= NULL
&& os
->processed_vma
)
567 new_rel (0, NULL
, os
->bfd_section
);
572 if (expld
.phase
!= lang_first_phase_enum
)
574 lang_output_section_statement_type
*os
;
576 os
= lang_output_section_find (tree
->name
.name
);
577 if (os
!= NULL
&& os
->processed_lma
)
579 if (os
->load_base
== NULL
)
580 new_rel (os
->bfd_section
->lma
- os
->bfd_section
->vma
,
581 NULL
, os
->bfd_section
);
583 exp_fold_tree_1 (os
->load_base
);
589 if (expld
.phase
!= lang_first_phase_enum
)
591 int opb
= bfd_octets_per_byte (output_bfd
);
592 lang_output_section_statement_type
*os
;
594 os
= lang_output_section_find (tree
->name
.name
);
597 else if (os
->processed_vma
)
598 new_abs (os
->bfd_section
->size
/ opb
);
604 lang_memory_region_type
*mem
;
606 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
608 new_abs (mem
->length
);
610 einfo (_("%F%S: undefined MEMORY region `%s'"
611 " referenced in expression\n"), tree
->name
.name
);
617 lang_memory_region_type
*mem
;
619 mem
= lang_memory_region_lookup (tree
->name
.name
, FALSE
);
621 new_abs (mem
->origin
);
623 einfo (_("%F%S: undefined MEMORY region `%s'"
624 " referenced in expression\n"), tree
->name
.name
);
629 if (strcmp (tree
->name
.name
, "MAXPAGESIZE") == 0)
630 new_abs (bfd_emul_get_maxpagesize (default_target
));
631 else if (strcmp (tree
->name
.name
, "COMMONPAGESIZE") == 0)
632 new_abs (bfd_emul_get_commonpagesize (default_target
));
634 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
645 exp_fold_tree_1 (etree_type
*tree
)
649 memset (&expld
.result
, 0, sizeof (expld
.result
));
653 switch (tree
->type
.node_class
)
656 new_rel (tree
->value
.value
, tree
->value
.str
, expld
.section
);
660 if (expld
.phase
!= lang_first_phase_enum
)
662 asection
*output_section
= tree
->rel
.section
->output_section
;
663 new_rel (tree
->rel
.value
+ tree
->rel
.section
->output_offset
,
664 NULL
, output_section
);
667 memset (&expld
.result
, 0, sizeof (expld
.result
));
671 exp_fold_tree_1 (tree
->assert_s
.child
);
672 if (expld
.phase
== lang_final_phase_enum
&& !expld
.result
.value
)
673 einfo ("%X%P: %s\n", tree
->assert_s
.message
);
691 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
693 /* Assignment to dot can only be done during allocation. */
694 if (tree
->type
.node_class
!= etree_assign
)
695 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
696 if (expld
.phase
== lang_mark_phase_enum
697 || expld
.phase
== lang_allocating_phase_enum
698 || (expld
.phase
== lang_final_phase_enum
699 && expld
.section
== bfd_abs_section_ptr
))
701 /* Notify the folder that this is an assignment to dot. */
702 expld
.assigning_to_dot
= TRUE
;
703 exp_fold_tree_1 (tree
->assign
.src
);
704 expld
.assigning_to_dot
= FALSE
;
706 if (!expld
.result
.valid_p
)
708 if (expld
.phase
!= lang_mark_phase_enum
)
709 einfo (_("%F%S invalid assignment to location counter\n"));
711 else if (expld
.dotp
== NULL
)
712 einfo (_("%F%S assignment to location counter"
713 " invalid outside of SECTION\n"));
718 nextdot
= expld
.result
.value
+ expld
.section
->vma
;
719 if (nextdot
< expld
.dot
720 && expld
.section
!= bfd_abs_section_ptr
)
721 einfo (_("%F%S cannot move location counter backwards"
722 " (from %V to %V)\n"), expld
.dot
, nextdot
);
726 *expld
.dotp
= nextdot
;
731 memset (&expld
.result
, 0, sizeof (expld
.result
));
735 struct bfd_link_hash_entry
*h
= NULL
;
737 if (tree
->type
.node_class
== etree_provide
)
739 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
742 || (h
->type
!= bfd_link_hash_new
743 && h
->type
!= bfd_link_hash_undefined
744 && h
->type
!= bfd_link_hash_common
))
746 /* Do nothing. The symbol was never referenced, or was
747 defined by some object. */
752 exp_fold_tree_1 (tree
->assign
.src
);
753 if (expld
.result
.valid_p
)
757 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
760 einfo (_("%P%F:%s: hash creation failed\n"),
764 /* FIXME: Should we worry if the symbol is already
766 lang_update_definedness (tree
->assign
.dst
, h
);
767 h
->type
= bfd_link_hash_defined
;
768 h
->u
.def
.value
= expld
.result
.value
;
769 h
->u
.def
.section
= expld
.result
.section
;
770 if (tree
->type
.node_class
== etree_provide
)
771 tree
->type
.node_class
= etree_provided
;
782 memset (&expld
.result
, 0, sizeof (expld
.result
));
788 exp_fold_tree (etree_type
*tree
, asection
*current_section
, bfd_vma
*dotp
)
792 expld
.section
= current_section
;
793 exp_fold_tree_1 (tree
);
797 exp_fold_tree_no_dot (etree_type
*tree
)
801 expld
.section
= bfd_abs_section_ptr
;
802 exp_fold_tree_1 (tree
);
806 exp_binop (int code
, etree_type
*lhs
, etree_type
*rhs
)
808 etree_type value
, *new;
810 value
.type
.node_code
= code
;
811 value
.binary
.lhs
= lhs
;
812 value
.binary
.rhs
= rhs
;
813 value
.type
.node_class
= etree_binary
;
814 exp_fold_tree_no_dot (&value
);
815 if (expld
.result
.valid_p
)
816 return exp_intop (expld
.result
.value
);
818 new = stat_alloc (sizeof (new->binary
));
819 memcpy (new, &value
, sizeof (new->binary
));
824 exp_trinop (int code
, etree_type
*cond
, etree_type
*lhs
, etree_type
*rhs
)
826 etree_type value
, *new;
828 value
.type
.node_code
= code
;
829 value
.trinary
.lhs
= lhs
;
830 value
.trinary
.cond
= cond
;
831 value
.trinary
.rhs
= rhs
;
832 value
.type
.node_class
= etree_trinary
;
833 exp_fold_tree_no_dot (&value
);
834 if (expld
.result
.valid_p
)
835 return exp_intop (expld
.result
.value
);
837 new = stat_alloc (sizeof (new->trinary
));
838 memcpy (new, &value
, sizeof (new->trinary
));
843 exp_unop (int code
, etree_type
*child
)
845 etree_type value
, *new;
847 value
.unary
.type
.node_code
= code
;
848 value
.unary
.child
= child
;
849 value
.unary
.type
.node_class
= etree_unary
;
850 exp_fold_tree_no_dot (&value
);
851 if (expld
.result
.valid_p
)
852 return exp_intop (expld
.result
.value
);
854 new = stat_alloc (sizeof (new->unary
));
855 memcpy (new, &value
, sizeof (new->unary
));
860 exp_nameop (int code
, const char *name
)
862 etree_type value
, *new;
864 value
.name
.type
.node_code
= code
;
865 value
.name
.name
= name
;
866 value
.name
.type
.node_class
= etree_name
;
868 exp_fold_tree_no_dot (&value
);
869 if (expld
.result
.valid_p
)
870 return exp_intop (expld
.result
.value
);
872 new = stat_alloc (sizeof (new->name
));
873 memcpy (new, &value
, sizeof (new->name
));
879 exp_assop (int code
, const char *dst
, etree_type
*src
)
883 new = stat_alloc (sizeof (new->assign
));
884 new->type
.node_code
= code
;
885 new->type
.node_class
= etree_assign
;
886 new->assign
.src
= src
;
887 new->assign
.dst
= dst
;
891 /* Handle PROVIDE. */
894 exp_provide (const char *dst
, etree_type
*src
, bfd_boolean hidden
)
898 n
= stat_alloc (sizeof (n
->assign
));
899 n
->assign
.type
.node_code
= '=';
900 n
->assign
.type
.node_class
= etree_provide
;
903 n
->assign
.hidden
= hidden
;
910 exp_assert (etree_type
*exp
, const char *message
)
914 n
= stat_alloc (sizeof (n
->assert_s
));
915 n
->assert_s
.type
.node_code
= '!';
916 n
->assert_s
.type
.node_class
= etree_assert
;
917 n
->assert_s
.child
= exp
;
918 n
->assert_s
.message
= message
;
923 exp_print_tree (etree_type
*tree
)
925 if (config
.map_file
== NULL
)
926 config
.map_file
= stderr
;
930 minfo ("NULL TREE\n");
934 switch (tree
->type
.node_class
)
937 minfo ("0x%v", tree
->value
.value
);
940 if (tree
->rel
.section
->owner
!= NULL
)
941 minfo ("%B:", tree
->rel
.section
->owner
);
942 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
945 fprintf (config
.map_file
, "%s", tree
->assign
.dst
);
946 exp_print_token (tree
->type
.node_code
, TRUE
);
947 exp_print_tree (tree
->assign
.src
);
951 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
952 exp_print_tree (tree
->assign
.src
);
953 fprintf (config
.map_file
, ")");
956 fprintf (config
.map_file
, "(");
957 exp_print_tree (tree
->binary
.lhs
);
958 exp_print_token (tree
->type
.node_code
, TRUE
);
959 exp_print_tree (tree
->binary
.rhs
);
960 fprintf (config
.map_file
, ")");
963 exp_print_tree (tree
->trinary
.cond
);
964 fprintf (config
.map_file
, "?");
965 exp_print_tree (tree
->trinary
.lhs
);
966 fprintf (config
.map_file
, ":");
967 exp_print_tree (tree
->trinary
.rhs
);
970 exp_print_token (tree
->unary
.type
.node_code
, FALSE
);
971 if (tree
->unary
.child
)
973 fprintf (config
.map_file
, " (");
974 exp_print_tree (tree
->unary
.child
);
975 fprintf (config
.map_file
, ")");
980 fprintf (config
.map_file
, "ASSERT (");
981 exp_print_tree (tree
->assert_s
.child
);
982 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
986 if (tree
->type
.node_code
== NAME
)
988 fprintf (config
.map_file
, "%s", tree
->name
.name
);
992 exp_print_token (tree
->type
.node_code
, FALSE
);
994 fprintf (config
.map_file
, " (%s)", tree
->name
.name
);
1004 exp_get_vma (etree_type
*tree
, bfd_vma def
, char *name
)
1008 exp_fold_tree_no_dot (tree
);
1009 if (expld
.result
.valid_p
)
1010 return expld
.result
.value
;
1011 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1012 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1018 exp_get_value_int (etree_type
*tree
, int def
, char *name
)
1020 return exp_get_vma (tree
, def
, name
);
1024 exp_get_fill (etree_type
*tree
, fill_type
*def
, char *name
)
1033 exp_fold_tree_no_dot (tree
);
1034 if (!expld
.result
.valid_p
)
1036 if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1037 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1041 if (expld
.result
.str
!= NULL
&& (len
= strlen (expld
.result
.str
)) != 0)
1045 fill
= xmalloc ((len
+ 1) / 2 + sizeof (*fill
) - 1);
1046 fill
->size
= (len
+ 1) / 2;
1048 s
= (unsigned char *) expld
.result
.str
;
1056 digit
= (digit
- 'A' + '0' + 10) & 0xf;
1070 fill
= xmalloc (4 + sizeof (*fill
) - 1);
1071 val
= expld
.result
.value
;
1072 fill
->data
[0] = (val
>> 24) & 0xff;
1073 fill
->data
[1] = (val
>> 16) & 0xff;
1074 fill
->data
[2] = (val
>> 8) & 0xff;
1075 fill
->data
[3] = (val
>> 0) & 0xff;
1082 exp_get_abs_int (etree_type
*tree
, int def
, char *name
)
1086 exp_fold_tree_no_dot (tree
);
1088 if (expld
.result
.valid_p
)
1090 expld
.result
.value
+= expld
.result
.section
->vma
;
1091 return expld
.result
.value
;
1093 else if (name
!= NULL
&& expld
.phase
!= lang_mark_phase_enum
)
1094 einfo (_("%F%S nonconstant expression for %s\n"), name
);
1100 align_n (bfd_vma value
, bfd_vma align
)
1105 value
= (value
+ align
- 1) / align
;
1106 return value
* align
;