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);