1 /* This module handles expression trees.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
4 Written by Steve Chamberlain of Cygnus Support (sac@cygnus.com).
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, 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 is
27 done by keeping all values in a struct (an etree_value_type) which
28 contains a value, a section to which it is relative and a valid bit.
43 static void exp_print_token
PARAMS ((token_code_type code
));
44 static void make_abs
PARAMS ((etree_value_type
*ptr
));
45 static etree_value_type new_abs
PARAMS ((bfd_vma value
));
46 static void check
PARAMS ((lang_output_section_statement_type
*os
,
47 const char *name
, const char *op
));
48 static etree_value_type new_rel
49 PARAMS ((bfd_vma value
, lang_output_section_statement_type
*section
));
50 static etree_value_type new_rel_from_section
51 PARAMS ((bfd_vma value
, lang_output_section_statement_type
*section
));
52 static etree_value_type fold_binary
53 PARAMS ((etree_type
*tree
,
54 lang_output_section_statement_type
*current_section
,
55 lang_phase_type allocation_done
,
56 bfd_vma dot
, bfd_vma
*dotp
));
57 static etree_value_type fold_name
58 PARAMS ((etree_type
*tree
,
59 lang_output_section_statement_type
*current_section
,
60 lang_phase_type allocation_done
,
62 static etree_value_type exp_fold_tree_no_dot
63 PARAMS ((etree_type
*tree
,
64 lang_output_section_statement_type
*current_section
,
65 lang_phase_type allocation_done
));
68 exp_print_token (code
)
78 { REL
, "relocateable" },
98 { SECTIONS
,"SECTIONS" },
99 { SIZEOF_HEADERS
,"SIZEOF_HEADERS" },
103 { LOADADDR
,"LOADADDR" },
105 { DEFINED
,"DEFINED" },
106 { TARGET_K
,"TARGET" },
107 { SEARCH_DIR
,"SEARCH_DIR" },
119 for (idx
= 0; table
[idx
].name
!= (char*)NULL
; idx
++) {
120 if (table
[idx
].code
== code
) {
121 fprintf(config
.map_file
, "%s", table
[idx
].name
);
125 /* Not in table, just print it alone */
126 fprintf(config
.map_file
, "%c",code
);
131 etree_value_type
*ptr
;
133 asection
*s
= ptr
->section
->bfd_section
;
134 ptr
->value
+= s
->vma
;
135 ptr
->section
= abs_output_section
;
138 static etree_value_type
142 etree_value_type
new;
144 new.section
= abs_output_section
;
151 lang_output_section_statement_type
*os
;
156 einfo (_("%F%P: %s uses undefined section %s\n"), op
, name
);
158 einfo (_("%F%P: %s forward reference of section %s\n"), op
, name
);
165 etree_type
*new = (etree_type
*) stat_alloc(sizeof(new->value
));
166 new->type
.node_code
= INT
;
167 new->value
.value
= value
;
168 new->type
.node_class
= etree_value
;
173 /* Build an expression representing an unnamed relocateable value. */
176 exp_relop (section
, value
)
180 etree_type
*new = (etree_type
*) stat_alloc (sizeof (new->rel
));
181 new->type
.node_code
= REL
;
182 new->type
.node_class
= etree_rel
;
183 new->rel
.section
= section
;
184 new->rel
.value
= value
;
188 static etree_value_type
189 new_rel (value
, section
)
191 lang_output_section_statement_type
*section
;
193 etree_value_type
new;
196 new.section
= section
;
200 static etree_value_type
201 new_rel_from_section (value
, section
)
203 lang_output_section_statement_type
*section
;
205 etree_value_type
new;
208 new.section
= section
;
210 new.value
-= section
->bfd_section
->vma
;
215 static etree_value_type
216 fold_binary (tree
, current_section
, allocation_done
, dot
, dotp
)
218 lang_output_section_statement_type
*current_section
;
219 lang_phase_type allocation_done
;
223 etree_value_type result
;
225 result
= exp_fold_tree (tree
->binary
.lhs
, current_section
,
226 allocation_done
, dot
, dotp
);
229 etree_value_type other
;
231 other
= exp_fold_tree (tree
->binary
.rhs
,
233 allocation_done
, dot
,dotp
) ;
236 /* If the values are from different sections, or this is an
237 absolute expression, make both the source arguments
238 absolute. However, adding or subtracting an absolute
239 value from a relative value is meaningful, and is an
241 if (current_section
!= abs_output_section
242 && (other
.section
== abs_output_section
243 || (result
.section
== abs_output_section
244 && tree
->type
.node_code
== '+'))
245 && (tree
->type
.node_code
== '+'
246 || tree
->type
.node_code
== '-'))
248 etree_value_type hold
;
250 /* If there is only one absolute term, make sure it is the
252 if (other
.section
!= abs_output_section
)
259 else if (result
.section
!= other
.section
260 || current_section
== abs_output_section
)
266 switch (tree
->type
.node_code
)
269 if (other
.value
== 0)
270 einfo (_("%F%S %% by zero\n"));
271 result
.value
= ((bfd_signed_vma
) result
.value
272 % (bfd_signed_vma
) other
.value
);
276 if (other
.value
== 0)
277 einfo (_("%F%S / by zero\n"));
278 result
.value
= ((bfd_signed_vma
) result
.value
279 / (bfd_signed_vma
) other
.value
);
282 #define BOP(x,y) case x : result.value = result.value y other.value; break;
301 if (result
.value
< other
.value
)
306 if (result
.value
> other
.value
)
316 result
.valid_p
= false;
326 etree_value_type
new;
331 static etree_value_type
332 fold_name (tree
, current_section
, allocation_done
, dot
)
334 lang_output_section_statement_type
*current_section
;
335 lang_phase_type allocation_done
;
338 etree_value_type result
;
339 switch (tree
->type
.node_code
)
342 if (allocation_done
!= lang_first_phase_enum
)
344 result
= new_abs ((bfd_vma
)
345 bfd_sizeof_headers (output_bfd
,
346 link_info
.relocateable
));
350 result
.valid_p
= false;
354 if (allocation_done
== lang_first_phase_enum
)
355 result
.valid_p
= false;
358 struct bfd_link_hash_entry
*h
;
360 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
363 result
.value
= (h
!= (struct bfd_link_hash_entry
*) NULL
364 && (h
->type
== bfd_link_hash_defined
365 || h
->type
== bfd_link_hash_defweak
366 || h
->type
== bfd_link_hash_common
));
368 result
.valid_p
= true;
372 result
.valid_p
= false;
373 if (tree
->name
.name
[0] == '.' && tree
->name
.name
[1] == 0)
375 if (allocation_done
!= lang_first_phase_enum
)
376 result
= new_rel_from_section(dot
, current_section
);
380 else if (allocation_done
!= lang_first_phase_enum
)
382 struct bfd_link_hash_entry
*h
;
384 h
= bfd_wrapped_link_hash_lookup (output_bfd
, &link_info
,
388 && (h
->type
== bfd_link_hash_defined
389 || h
->type
== bfd_link_hash_defweak
))
391 if (bfd_is_abs_section (h
->u
.def
.section
))
392 result
= new_abs (h
->u
.def
.value
);
393 else if (allocation_done
== lang_final_phase_enum
394 || allocation_done
== lang_allocating_phase_enum
)
396 asection
*output_section
;
398 output_section
= h
->u
.def
.section
->output_section
;
399 if (output_section
== NULL
)
400 einfo (_("%X%S: unresolvable symbol `%s' referenced in expression\n"),
404 lang_output_section_statement_type
*os
;
406 os
= (lang_output_section_statement_lookup
407 (bfd_get_section_name (output_bfd
,
410 /* FIXME: Is this correct if this section is
411 being linked with -R? */
412 result
= new_rel ((h
->u
.def
.value
413 + h
->u
.def
.section
->output_offset
),
418 else if (allocation_done
== lang_final_phase_enum
)
419 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
425 if (allocation_done
!= lang_first_phase_enum
)
427 lang_output_section_statement_type
*os
;
429 os
= lang_output_section_find (tree
->name
.name
);
430 check (os
, tree
->name
.name
, "ADDR");
431 result
= new_rel (0, os
);
438 if (allocation_done
!= lang_first_phase_enum
)
440 lang_output_section_statement_type
*os
;
442 os
= lang_output_section_find (tree
->name
.name
);
443 check (os
, tree
->name
.name
, "LOADADDR");
444 if (os
->load_base
== NULL
)
445 result
= new_rel (0, os
);
447 result
= exp_fold_tree_no_dot (os
->load_base
,
456 if (allocation_done
!= lang_first_phase_enum
)
458 int opb
= bfd_octets_per_byte (output_bfd
);
459 lang_output_section_statement_type
*os
;
461 os
= lang_output_section_find (tree
->name
.name
);
462 check (os
, tree
->name
.name
, "SIZEOF");
463 result
= new_abs (os
->bfd_section
->_raw_size
/ opb
);
477 exp_fold_tree (tree
, current_section
, allocation_done
, dot
, dotp
)
479 lang_output_section_statement_type
*current_section
;
480 lang_phase_type allocation_done
;
484 etree_value_type result
;
488 result
.valid_p
= false;
492 switch (tree
->type
.node_class
)
495 result
= new_rel (tree
->value
.value
, current_section
);
499 if (allocation_done
!= lang_final_phase_enum
)
500 result
.valid_p
= false;
502 result
= new_rel ((tree
->rel
.value
503 + tree
->rel
.section
->output_section
->vma
504 + tree
->rel
.section
->output_offset
),
509 result
= exp_fold_tree (tree
->assert_s
.child
,
511 allocation_done
, dot
, dotp
);
515 einfo ("%F%P: %s\n", tree
->assert_s
.message
);
521 result
= exp_fold_tree (tree
->unary
.child
,
523 allocation_done
, dot
, dotp
);
526 switch (tree
->type
.node_code
)
529 if (allocation_done
!= lang_first_phase_enum
)
530 result
= new_rel_from_section (ALIGN_N (dot
, result
.value
),
533 result
.valid_p
= false;
537 if (allocation_done
!= lang_first_phase_enum
&& result
.valid_p
)
539 result
.value
+= result
.section
->bfd_section
->vma
;
540 result
.section
= abs_output_section
;
543 result
.valid_p
= false;
548 result
.value
= ~result
.value
;
553 result
.value
= !result
.value
;
558 result
.value
= -result
.value
;
562 /* Return next place aligned to value. */
563 if (allocation_done
== lang_allocating_phase_enum
)
566 result
.value
= ALIGN_N (dot
, result
.value
);
569 result
.valid_p
= false;
580 result
= exp_fold_tree (tree
->trinary
.cond
, current_section
,
581 allocation_done
, dot
, dotp
);
583 result
= exp_fold_tree ((result
.value
585 : tree
->trinary
.rhs
),
587 allocation_done
, dot
, dotp
);
591 result
= fold_binary (tree
, current_section
, allocation_done
,
597 if (tree
->assign
.dst
[0] == '.' && tree
->assign
.dst
[1] == 0)
599 /* Assignment to dot can only be done during allocation */
600 if (tree
->type
.node_class
== etree_provide
)
601 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
602 if (allocation_done
== lang_allocating_phase_enum
603 || (allocation_done
== lang_final_phase_enum
604 && current_section
== abs_output_section
))
606 result
= exp_fold_tree (tree
->assign
.src
,
608 lang_allocating_phase_enum
, dot
,
610 if (! result
.valid_p
)
611 einfo (_("%F%S invalid assignment to location counter\n"));
614 if (current_section
== NULL
)
615 einfo (_("%F%S assignment to location counter invalid outside of SECTION\n"));
620 nextdot
= (result
.value
621 + current_section
->bfd_section
->vma
);
623 && current_section
!= abs_output_section
)
625 einfo (_("%F%S cannot move location counter backwards (from %V to %V)\n"),
636 result
= exp_fold_tree (tree
->assign
.src
,
637 current_section
, allocation_done
,
642 struct bfd_link_hash_entry
*h
;
644 if (tree
->type
.node_class
== etree_assign
)
648 h
= bfd_link_hash_lookup (link_info
.hash
, tree
->assign
.dst
,
649 create
, false, false);
650 if (h
== (struct bfd_link_hash_entry
*) NULL
)
652 if (tree
->type
.node_class
== etree_assign
)
653 einfo (_("%P%F:%s: hash creation failed\n"),
656 else if (tree
->type
.node_class
== etree_provide
657 && h
->type
!= bfd_link_hash_undefined
658 && h
->type
!= bfd_link_hash_common
)
660 /* Do nothing. The symbol was defined by some
665 /* FIXME: Should we worry if the symbol is already
667 h
->type
= bfd_link_hash_defined
;
668 h
->u
.def
.value
= result
.value
;
669 h
->u
.def
.section
= result
.section
->bfd_section
;
676 result
= fold_name (tree
, current_section
, allocation_done
, dot
);
687 static etree_value_type
688 exp_fold_tree_no_dot (tree
, current_section
, allocation_done
)
690 lang_output_section_statement_type
*current_section
;
691 lang_phase_type allocation_done
;
693 return exp_fold_tree(tree
, current_section
, allocation_done
, (bfd_vma
)
698 exp_binop (code
, lhs
, rhs
)
703 etree_type value
, *new;
706 value
.type
.node_code
= code
;
707 value
.binary
.lhs
= lhs
;
708 value
.binary
.rhs
= rhs
;
709 value
.type
.node_class
= etree_binary
;
710 r
= exp_fold_tree_no_dot(&value
,
712 lang_first_phase_enum
);
715 return exp_intop(r
.value
);
717 new = (etree_type
*) stat_alloc (sizeof (new->binary
));
718 memcpy((char *)new, (char *)&value
, sizeof(new->binary
));
723 exp_trinop (code
, cond
, lhs
, rhs
)
729 etree_type value
, *new;
731 value
.type
.node_code
= code
;
732 value
.trinary
.lhs
= lhs
;
733 value
.trinary
.cond
= cond
;
734 value
.trinary
.rhs
= rhs
;
735 value
.type
.node_class
= etree_trinary
;
736 r
= exp_fold_tree_no_dot(&value
, (lang_output_section_statement_type
737 *)NULL
,lang_first_phase_enum
);
739 return exp_intop(r
.value
);
741 new = (etree_type
*) stat_alloc (sizeof (new->trinary
));
742 memcpy((char *)new,(char *) &value
, sizeof(new->trinary
));
747 exp_unop (code
, child
)
751 etree_type value
, *new;
754 value
.unary
.type
.node_code
= code
;
755 value
.unary
.child
= child
;
756 value
.unary
.type
.node_class
= etree_unary
;
757 r
= exp_fold_tree_no_dot(&value
,abs_output_section
,
758 lang_first_phase_enum
);
760 return exp_intop(r
.value
);
762 new = (etree_type
*) stat_alloc (sizeof (new->unary
));
763 memcpy((char *)new, (char *)&value
, sizeof(new->unary
));
768 exp_nameop (code
, name
)
772 etree_type value
, *new;
774 value
.name
.type
.node_code
= code
;
775 value
.name
.name
= name
;
776 value
.name
.type
.node_class
= etree_name
;
778 r
= exp_fold_tree_no_dot(&value
,
779 (lang_output_section_statement_type
*)NULL
,
780 lang_first_phase_enum
);
782 return exp_intop(r
.value
);
784 new = (etree_type
*) stat_alloc (sizeof (new->name
));
785 memcpy((char *)new, (char *)&value
, sizeof(new->name
));
791 exp_assop (code
, dst
, src
)
796 etree_type value
, *new;
798 value
.assign
.type
.node_code
= code
;
800 value
.assign
.src
= src
;
801 value
.assign
.dst
= dst
;
802 value
.assign
.type
.node_class
= etree_assign
;
805 if (exp_fold_tree_no_dot(&value
, &result
)) {
806 return exp_intop(result
);
809 new = (etree_type
*) stat_alloc (sizeof (new->assign
));
810 memcpy((char *)new, (char *)&value
, sizeof(new->assign
));
814 /* Handle PROVIDE. */
817 exp_provide (dst
, src
)
823 n
= (etree_type
*) stat_alloc (sizeof (n
->assign
));
824 n
->assign
.type
.node_code
= '=';
825 n
->assign
.type
.node_class
= etree_provide
;
834 exp_assert (exp
, message
)
840 n
= (etree_type
*) stat_alloc (sizeof (n
->assert_s
));
841 n
->assert_s
.type
.node_code
= '!';
842 n
->assert_s
.type
.node_class
= etree_assert
;
843 n
->assert_s
.child
= exp
;
844 n
->assert_s
.message
= message
;
849 exp_print_tree (tree
)
852 switch (tree
->type
.node_class
) {
854 minfo ("0x%v", tree
->value
.value
);
857 if (tree
->rel
.section
->owner
!= NULL
)
858 minfo ("%B:", tree
->rel
.section
->owner
);
859 minfo ("%s+0x%v", tree
->rel
.section
->name
, tree
->rel
.value
);
863 if (tree
->assign
.dst
->sdefs
!= (asymbol
*)NULL
){
864 fprintf(config
.map_file
,"%s (%x) ",tree
->assign
.dst
->name
,
865 tree
->assign
.dst
->sdefs
->value
);
868 fprintf(config
.map_file
,"%s (UNDEFINED)",tree
->assign
.dst
->name
);
871 fprintf(config
.map_file
,"%s",tree
->assign
.dst
);
872 exp_print_token(tree
->type
.node_code
);
873 exp_print_tree(tree
->assign
.src
);
876 fprintf (config
.map_file
, "PROVIDE (%s, ", tree
->assign
.dst
);
877 exp_print_tree (tree
->assign
.src
);
878 fprintf (config
.map_file
, ")");
881 fprintf(config
.map_file
,"(");
882 exp_print_tree(tree
->binary
.lhs
);
883 exp_print_token(tree
->type
.node_code
);
884 exp_print_tree(tree
->binary
.rhs
);
885 fprintf(config
.map_file
,")");
888 exp_print_tree(tree
->trinary
.cond
);
889 fprintf(config
.map_file
,"?");
890 exp_print_tree(tree
->trinary
.lhs
);
891 fprintf(config
.map_file
,":");
892 exp_print_tree(tree
->trinary
.rhs
);
895 exp_print_token(tree
->unary
.type
.node_code
);
896 if (tree
->unary
.child
)
898 fprintf(config
.map_file
,"(");
899 exp_print_tree(tree
->unary
.child
);
900 fprintf(config
.map_file
,")");
906 fprintf (config
.map_file
, "ASSERT (");
907 exp_print_tree (tree
->assert_s
.child
);
908 fprintf (config
.map_file
, ", %s)", tree
->assert_s
.message
);
912 fprintf(config
.map_file
,"????????");
915 if (tree
->type
.node_code
== NAME
) {
916 fprintf(config
.map_file
,"%s", tree
->name
.name
);
919 exp_print_token(tree
->type
.node_code
);
921 fprintf(config
.map_file
,"(%s)", tree
->name
.name
);
931 exp_get_vma (tree
, def
, name
, allocation_done
)
935 lang_phase_type allocation_done
;
941 r
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
942 if (! r
.valid_p
&& name
!= NULL
)
943 einfo (_("%F%S nonconstant expression for %s\n"), name
);
951 exp_get_value_int (tree
,def
,name
, allocation_done
)
955 lang_phase_type allocation_done
;
957 return (int)exp_get_vma(tree
,(bfd_vma
)def
,name
, allocation_done
);
961 exp_get_abs_int (tree
, def
, name
, allocation_done
)
963 int def ATTRIBUTE_UNUSED
;
965 lang_phase_type allocation_done
;
967 etree_value_type res
;
968 res
= exp_fold_tree_no_dot (tree
, abs_output_section
, allocation_done
);
972 res
.value
+= res
.section
->bfd_section
->vma
;
975 einfo (_("%F%S non constant expression for %s\n"),name
);