source: trunk/src/binutils/ld/ldexp.c@ 108

Last change on this file since 108 was 10, checked in by bird, 23 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 23.9 KB
Line 
1/* This module handles expression trees.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001
4 Free Software Foundation, Inc.
5 Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
6
7This file is part of GLD, the Gnu Linker.
8
9GLD is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GLD is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GLD; see the file COPYING. If not, write to the Free
21Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2202111-1307, USA. */
23
24/* This module is in charge of working out the contents of expressions.
25
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
29 valid bit. */
30
31#include "bfd.h"
32#include "sysdep.h"
33#include "bfdlink.h"
34
35#include "ld.h"
36#include "ldmain.h"
37#include "ldmisc.h"
38#include "ldexp.h"
39#include "ldgram.h"
40#include "ldlang.h"
41
42static void exp_print_token PARAMS ((token_code_type code));
43static void make_abs PARAMS ((etree_value_type *ptr));
44static etree_value_type new_abs PARAMS ((bfd_vma value));
45static void check PARAMS ((lang_output_section_statement_type *os,
46 const char *name, const char *op));
47static etree_value_type new_rel
48 PARAMS ((bfd_vma value, lang_output_section_statement_type *section));
49static etree_value_type new_rel_from_section
50 PARAMS ((bfd_vma value, lang_output_section_statement_type *section));
51static etree_value_type fold_binary
52 PARAMS ((etree_type *tree,
53 lang_output_section_statement_type *current_section,
54 lang_phase_type allocation_done,
55 bfd_vma dot, bfd_vma *dotp));
56static etree_value_type fold_name
57 PARAMS ((etree_type *tree,
58 lang_output_section_statement_type *current_section,
59 lang_phase_type allocation_done,
60 bfd_vma dot));
61static etree_value_type exp_fold_tree_no_dot
62 PARAMS ((etree_type *tree,
63 lang_output_section_statement_type *current_section,
64 lang_phase_type allocation_done));
65
66static void
67exp_print_token (code)
68 token_code_type code;
69{
70 static CONST struct {
71 token_code_type code;
72 char *name;
73 } table[] = {
74 { INT, "int" },
75 { REL, "relocateable" },
76 { NAME, "NAME" },
77 { PLUSEQ, "+=" },
78 { MINUSEQ, "-=" },
79 { MULTEQ, "*=" },
80 { DIVEQ, "/=" },
81 { LSHIFTEQ, "<<=" },
82 { RSHIFTEQ, ">>=" },
83 { ANDEQ, "&=" },
84 { OREQ, "|=" },
85 { OROR, "||" },
86 { ANDAND, "&&" },
87 { EQ, "==" },
88 { NE, "!=" },
89 { LE, "<=" },
90 { GE, ">=" },
91 { LSHIFT, "<<" },
92 { RSHIFT, ">>=" },
93 { ALIGN_K, "ALIGN" },
94 { BLOCK, "BLOCK" },
95 { SECTIONS, "SECTIONS" },
96 { SIZEOF_HEADERS, "SIZEOF_HEADERS" },
97 { NEXT, "NEXT" },
98 { SIZEOF, "SIZEOF" },
99 { ADDR, "ADDR" },
100 { LOADADDR, "LOADADDR" },
101 { MEMORY, "MEMORY" },
102 { DEFINED, "DEFINED" },
103 { TARGET_K, "TARGET" },
104 { SEARCH_DIR, "SEARCH_DIR" },
105 { MAP, "MAP" },
106 { QUAD, "QUAD" },
107 { SQUAD, "SQUAD" },
108 { LONG, "LONG" },
109 { SHORT, "SHORT" },
110 { BYTE, "BYTE" },
111 { ENTRY, "ENTRY" },
112 { 0, (char *) NULL }
113 };
114 unsigned int idx;
115
116 for (idx = 0; table[idx].name != (char *) NULL; idx++)
117 {
118 if (table[idx].code == code)
119 {
120 fprintf (config.map_file, "%s", table[idx].name);
121 return;
122 }
123 }
124 /* Not in table, just print it alone */
125 fprintf (config.map_file, "%c", code);
126}
127
128static void
129make_abs (ptr)
130 etree_value_type *ptr;
131{
132 asection *s = ptr->section->bfd_section;
133 ptr->value += s->vma;
134 ptr->section = abs_output_section;
135}
136
137static etree_value_type
138new_abs (value)
139 bfd_vma value;
140{
141 etree_value_type new;
142 new.valid_p = true;
143 new.section = abs_output_section;
144 new.value = value;
145 return new;
146}
147
148static void
149check (os, name, op)
150 lang_output_section_statement_type *os;
151 const char *name;
152 const char *op;
153{
154 if (os == NULL)
155 einfo (_("%F%P: %s uses undefined section %s\n"), op, name);
156 if (! os->processed)
157 einfo (_("%F%P: %s forward reference of section %s\n"), op, name);
158}
159
160etree_type *
161exp_intop (value)
162 bfd_vma value;
163{
164 etree_type *new = (etree_type *) stat_alloc (sizeof (new->value));
165 new->type.node_code = INT;
166 new->value.value = value;
167 new->type.node_class = etree_value;
168 return new;
169
170}
171
172/* Build an expression representing an unnamed relocateable value. */
173
174etree_type *
175exp_relop (section, value)
176 asection *section;
177 bfd_vma value;
178{
179 etree_type *new = (etree_type *) stat_alloc (sizeof (new->rel));
180 new->type.node_code = REL;
181 new->type.node_class = etree_rel;
182 new->rel.section = section;
183 new->rel.value = value;
184 return new;
185}
186
187static etree_value_type
188new_rel (value, section)
189 bfd_vma value;
190 lang_output_section_statement_type *section;
191{
192 etree_value_type new;
193 new.valid_p = true;
194 new.value = value;
195 new.section = section;
196 return new;
197}
198
199static etree_value_type
200new_rel_from_section (value, section)
201 bfd_vma value;
202 lang_output_section_statement_type *section;
203{
204 etree_value_type new;
205 new.valid_p = true;
206 new.value = value;
207 new.section = section;
208
209 new.value -= section->bfd_section->vma;
210
211 return new;
212}
213
214static etree_value_type
215fold_binary (tree, current_section, allocation_done, dot, dotp)
216 etree_type *tree;
217 lang_output_section_statement_type *current_section;
218 lang_phase_type allocation_done;
219 bfd_vma dot;
220 bfd_vma *dotp;
221{
222 etree_value_type result;
223
224 result = exp_fold_tree (tree->binary.lhs, current_section,
225 allocation_done, dot, dotp);
226 if (result.valid_p)
227 {
228 etree_value_type other;
229
230 other = exp_fold_tree (tree->binary.rhs,
231 current_section,
232 allocation_done, dot, dotp);
233 if (other.valid_p)
234 {
235 /* If the values are from different sections, or this is an
236 absolute expression, make both the source arguments
237 absolute. However, adding or subtracting an absolute
238 value from a relative value is meaningful, and is an
239 exception. */
240 if (current_section != abs_output_section
241 && (other.section == abs_output_section
242 || (result.section == abs_output_section
243 && tree->type.node_code == '+'))
244 && (tree->type.node_code == '+'
245 || tree->type.node_code == '-'))
246 {
247 etree_value_type hold;
248
249 /* If there is only one absolute term, make sure it is the
250 second one. */
251 if (other.section != abs_output_section)
252 {
253 hold = result;
254 result = other;
255 other = hold;
256 }
257 }
258 else if (result.section != other.section
259 || current_section == abs_output_section)
260 {
261 make_abs (&result);
262 make_abs (&other);
263 }
264
265 switch (tree->type.node_code)
266 {
267 case '%':
268 if (other.value == 0)
269 einfo (_("%F%S %% by zero\n"));
270 result.value = ((bfd_signed_vma) result.value
271 % (bfd_signed_vma) other.value);
272 break;
273
274 case '/':
275 if (other.value == 0)
276 einfo (_("%F%S / by zero\n"));
277 result.value = ((bfd_signed_vma) result.value
278 / (bfd_signed_vma) other.value);
279 break;
280
281#define BOP(x,y) case x : result.value = result.value y other.value; break;
282 BOP ('+', +);
283 BOP ('*', *);
284 BOP ('-', -);
285 BOP (LSHIFT, <<);
286 BOP (RSHIFT, >>);
287 BOP (EQ, ==);
288 BOP (NE, !=);
289 BOP ('<', <);
290 BOP ('>', >);
291 BOP (LE, <=);
292 BOP (GE, >=);
293 BOP ('&', &);
294 BOP ('^', ^);
295 BOP ('|', |);
296 BOP (ANDAND, &&);
297 BOP (OROR, ||);
298
299 case MAX_K:
300 if (result.value < other.value)
301 result = other;
302 break;
303
304 case MIN_K:
305 if (result.value > other.value)
306 result = other;
307 break;
308
309 default:
310 FAIL ();
311 }
312 }
313 else
314 {
315 result.valid_p = false;
316 }
317 }
318
319 return result;
320}
321
322etree_value_type
323invalid ()
324{
325 etree_value_type new;
326 new.valid_p = false;
327 return new;
328}
329
330static etree_value_type
331fold_name (tree, current_section, allocation_done, dot)
332 etree_type *tree;
333 lang_output_section_statement_type *current_section;
334 lang_phase_type allocation_done;
335 bfd_vma dot;
336{
337 etree_value_type result;
338 switch (tree->type.node_code)
339 {
340 case SIZEOF_HEADERS:
341 if (allocation_done != lang_first_phase_enum)
342 {
343 result = new_abs ((bfd_vma)
344 bfd_sizeof_headers (output_bfd,
345 link_info.relocateable));
346 }
347 else
348 {
349 result.valid_p = false;
350 }
351 break;
352 case DEFINED:
353 if (allocation_done == lang_first_phase_enum)
354 result.valid_p = false;
355 else
356 {
357 struct bfd_link_hash_entry *h;
358
359 h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
360 tree->name.name,
361 false, false, true);
362 result.value = (h != (struct bfd_link_hash_entry *) NULL
363 && (h->type == bfd_link_hash_defined
364 || h->type == bfd_link_hash_defweak
365 || h->type == bfd_link_hash_common));
366 result.section = 0;
367 result.valid_p = true;
368 }
369 break;
370 case NAME:
371 result.valid_p = false;
372 if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
373 {
374 if (allocation_done != lang_first_phase_enum)
375 result = new_rel_from_section (dot, current_section);
376 else
377 result = invalid ();
378 }
379 else if (allocation_done != lang_first_phase_enum)
380 {
381 struct bfd_link_hash_entry *h;
382
383 h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
384 tree->name.name,
385 false, false, true);
386 if (h != NULL
387 && (h->type == bfd_link_hash_defined
388 || h->type == bfd_link_hash_defweak))
389 {
390 if (bfd_is_abs_section (h->u.def.section))
391 result = new_abs (h->u.def.value);
392 else if (allocation_done == lang_final_phase_enum
393 || allocation_done == lang_allocating_phase_enum)
394 {
395 asection *output_section;
396
397 output_section = h->u.def.section->output_section;
398 if (output_section == NULL)
399 einfo (_("%X%S: unresolvable symbol `%s' referenced in expression\n"),
400 tree->name.name);
401 else
402 {
403 lang_output_section_statement_type *os;
404
405 os = (lang_output_section_statement_lookup
406 (bfd_get_section_name (output_bfd,
407 output_section)));
408
409 /* FIXME: Is this correct if this section is
410 being linked with -R? */
411 result = new_rel ((h->u.def.value
412 + h->u.def.section->output_offset),
413 os);
414 }
415 }
416 }
417 else if (allocation_done == lang_final_phase_enum)
418 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
419 tree->name.name);
420 }
421 break;
422
423 case ADDR:
424 if (allocation_done != lang_first_phase_enum)
425 {
426 lang_output_section_statement_type *os;
427
428 os = lang_output_section_find (tree->name.name);
429 check (os, tree->name.name, "ADDR");
430 result = new_rel (0, os);
431 }
432 else
433 result = invalid ();
434 break;
435
436 case LOADADDR:
437 if (allocation_done != lang_first_phase_enum)
438 {
439 lang_output_section_statement_type *os;
440
441 os = lang_output_section_find (tree->name.name);
442 check (os, tree->name.name, "LOADADDR");
443 if (os->load_base == NULL)
444 result = new_rel (0, os);
445 else
446 result = exp_fold_tree_no_dot (os->load_base,
447 abs_output_section,
448 allocation_done);
449 }
450 else
451 result = invalid ();
452 break;
453
454 case SIZEOF:
455 if (allocation_done != lang_first_phase_enum)
456 {
457 int opb = bfd_octets_per_byte (output_bfd);
458 lang_output_section_statement_type *os;
459
460 os = lang_output_section_find (tree->name.name);
461 check (os, tree->name.name, "SIZEOF");
462 result = new_abs (os->bfd_section->_raw_size / opb);
463 }
464 else
465 result = invalid ();
466 break;
467
468 default:
469 FAIL ();
470 break;
471 }
472
473 return result;
474}
475
476etree_value_type
477exp_fold_tree (tree, current_section, allocation_done, dot, dotp)
478 etree_type *tree;
479 lang_output_section_statement_type *current_section;
480 lang_phase_type allocation_done;
481 bfd_vma dot;
482 bfd_vma *dotp;
483{
484 etree_value_type result;
485
486 if (tree == NULL)
487 {
488 result.valid_p = false;
489 return result;
490 }
491
492 switch (tree->type.node_class)
493 {
494 case etree_value:
495 result = new_rel (tree->value.value, current_section);
496 break;
497
498 case etree_rel:
499 if (allocation_done != lang_final_phase_enum)
500 result.valid_p = false;
501 else
502 result = new_rel ((tree->rel.value
503 + tree->rel.section->output_section->vma
504 + tree->rel.section->output_offset),
505 current_section);
506 break;
507
508 case etree_assert:
509 result = exp_fold_tree (tree->assert_s.child,
510 current_section,
511 allocation_done, dot, dotp);
512 if (result.valid_p)
513 {
514 if (! result.value)
515 einfo ("%F%P: %s\n", tree->assert_s.message);
516 return result;
517 }
518 break;
519
520 case etree_unary:
521 result = exp_fold_tree (tree->unary.child,
522 current_section,
523 allocation_done, dot, dotp);
524 if (result.valid_p)
525 {
526 switch (tree->type.node_code)
527 {
528 case ALIGN_K:
529 if (allocation_done != lang_first_phase_enum)
530 result = new_rel_from_section (ALIGN_N (dot, result.value),
531 current_section);
532 else
533 result.valid_p = false;
534 break;
535
536 case ABSOLUTE:
537 if (allocation_done != lang_first_phase_enum && result.valid_p)
538 {
539 result.value += result.section->bfd_section->vma;
540 result.section = abs_output_section;
541 }
542 else
543 result.valid_p = false;
544 break;
545
546 case '~':
547 make_abs (&result);
548 result.value = ~result.value;
549 break;
550
551 case '!':
552 make_abs (&result);
553 result.value = !result.value;
554 break;
555
556 case '-':
557 make_abs (&result);
558 result.value = -result.value;
559 break;
560
561 case NEXT:
562 /* Return next place aligned to value. */
563 if (allocation_done == lang_allocating_phase_enum)
564 {
565 make_abs (&result);
566 result.value = ALIGN_N (dot, result.value);
567 }
568 else
569 result.valid_p = false;
570 break;
571
572 default:
573 FAIL ();
574 break;
575 }
576 }
577 break;
578
579 case etree_trinary:
580 result = exp_fold_tree (tree->trinary.cond, current_section,
581 allocation_done, dot, dotp);
582 if (result.valid_p)
583 result = exp_fold_tree ((result.value
584 ? tree->trinary.lhs
585 : tree->trinary.rhs),
586 current_section,
587 allocation_done, dot, dotp);
588 break;
589
590 case etree_binary:
591 result = fold_binary (tree, current_section, allocation_done,
592 dot, dotp);
593 break;
594
595 case etree_assign:
596 case etree_provide:
597 case etree_provided:
598 if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
599 {
600 /* Assignment to dot can only be done during allocation */
601 if (tree->type.node_class != etree_assign)
602 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
603 if (allocation_done == lang_allocating_phase_enum
604 || (allocation_done == lang_final_phase_enum
605 && current_section == abs_output_section))
606 {
607 result = exp_fold_tree (tree->assign.src,
608 current_section,
609 lang_allocating_phase_enum, dot,
610 dotp);
611 if (! result.valid_p)
612 einfo (_("%F%S invalid assignment to location counter\n"));
613 else
614 {
615 if (current_section == NULL)
616 einfo (_("%F%S assignment to location counter invalid outside of SECTION\n"));
617 else
618 {
619 bfd_vma nextdot;
620
621 nextdot = (result.value
622 + current_section->bfd_section->vma);
623 if (nextdot < dot
624 && current_section != abs_output_section)
625 {
626 einfo (_("%F%S cannot move location counter backwards (from %V to %V)\n"),
627 dot, nextdot);
628 }
629 else
630 *dotp = nextdot;
631 }
632 }
633 }
634 }
635 else
636 {
637 result = exp_fold_tree (tree->assign.src,
638 current_section, allocation_done,
639 dot, dotp);
640 if (result.valid_p)
641 {
642 boolean create;
643 struct bfd_link_hash_entry *h;
644
645 if (tree->type.node_class == etree_assign)
646 create = true;
647 else
648 create = false;
649 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
650 create, false, false);
651 if (h == (struct bfd_link_hash_entry *) NULL)
652 {
653 if (tree->type.node_class == etree_assign)
654 einfo (_("%P%F:%s: hash creation failed\n"),
655 tree->assign.dst);
656 }
657 else if (tree->type.node_class == etree_provide
658 && h->type != bfd_link_hash_undefined
659 && h->type != bfd_link_hash_common)
660 {
661 /* Do nothing. The symbol was defined by some
662 object. */
663 }
664 else
665 {
666 /* FIXME: Should we worry if the symbol is already
667 defined? */
668 h->type = bfd_link_hash_defined;
669 h->u.def.value = result.value;
670 h->u.def.section = result.section->bfd_section;
671 if (tree->type.node_class == etree_provide)
672 tree->type.node_class = etree_provided;
673 }
674 }
675 }
676 break;
677
678 case etree_name:
679 result = fold_name (tree, current_section, allocation_done, dot);
680 break;
681
682 default:
683 FAIL ();
684 break;
685 }
686
687 return result;
688}
689
690static etree_value_type
691exp_fold_tree_no_dot (tree, current_section, allocation_done)
692 etree_type *tree;
693 lang_output_section_statement_type *current_section;
694 lang_phase_type allocation_done;
695{
696 return exp_fold_tree (tree, current_section, allocation_done,
697 (bfd_vma) 0, (bfd_vma *) NULL);
698}
699
700etree_type *
701exp_binop (code, lhs, rhs)
702 int code;
703 etree_type *lhs;
704 etree_type *rhs;
705{
706 etree_type value, *new;
707 etree_value_type r;
708
709 value.type.node_code = code;
710 value.binary.lhs = lhs;
711 value.binary.rhs = rhs;
712 value.type.node_class = etree_binary;
713 r = exp_fold_tree_no_dot (&value,
714 abs_output_section,
715 lang_first_phase_enum);
716 if (r.valid_p)
717 {
718 return exp_intop (r.value);
719 }
720 new = (etree_type *) stat_alloc (sizeof (new->binary));
721 memcpy ((char *) new, (char *) &value, sizeof (new->binary));
722 return new;
723}
724
725etree_type *
726exp_trinop (code, cond, lhs, rhs)
727 int code;
728 etree_type *cond;
729 etree_type *lhs;
730 etree_type *rhs;
731{
732 etree_type value, *new;
733 etree_value_type r;
734 value.type.node_code = code;
735 value.trinary.lhs = lhs;
736 value.trinary.cond = cond;
737 value.trinary.rhs = rhs;
738 value.type.node_class = etree_trinary;
739 r = exp_fold_tree_no_dot (&value,
740 (lang_output_section_statement_type *) NULL,
741 lang_first_phase_enum);
742 if (r.valid_p)
743 {
744 return exp_intop (r.value);
745 }
746 new = (etree_type *) stat_alloc (sizeof (new->trinary));
747 memcpy ((char *) new, (char *) &value, sizeof (new->trinary));
748 return new;
749}
750
751etree_type *
752exp_unop (code, child)
753 int code;
754 etree_type *child;
755{
756 etree_type value, *new;
757
758 etree_value_type r;
759 value.unary.type.node_code = code;
760 value.unary.child = child;
761 value.unary.type.node_class = etree_unary;
762 r = exp_fold_tree_no_dot (&value, abs_output_section,
763 lang_first_phase_enum);
764 if (r.valid_p)
765 {
766 return exp_intop (r.value);
767 }
768 new = (etree_type *) stat_alloc (sizeof (new->unary));
769 memcpy ((char *) new, (char *) &value, sizeof (new->unary));
770 return new;
771}
772
773etree_type *
774exp_nameop (code, name)
775 int code;
776 CONST char *name;
777{
778 etree_type value, *new;
779 etree_value_type r;
780 value.name.type.node_code = code;
781 value.name.name = name;
782 value.name.type.node_class = etree_name;
783
784 r = exp_fold_tree_no_dot (&value,
785 (lang_output_section_statement_type *) NULL,
786 lang_first_phase_enum);
787 if (r.valid_p)
788 {
789 return exp_intop (r.value);
790 }
791 new = (etree_type *) stat_alloc (sizeof (new->name));
792 memcpy ((char *) new, (char *) &value, sizeof (new->name));
793 return new;
794
795}
796
797etree_type *
798exp_assop (code, dst, src)
799 int code;
800 CONST char *dst;
801 etree_type *src;
802{
803 etree_type value, *new;
804
805 value.assign.type.node_code = code;
806
807 value.assign.src = src;
808 value.assign.dst = dst;
809 value.assign.type.node_class = etree_assign;
810
811#if 0
812 if (exp_fold_tree_no_dot (&value, &result))
813 {
814 return exp_intop (result);
815 }
816#endif
817 new = (etree_type *) stat_alloc (sizeof (new->assign));
818 memcpy ((char *) new, (char *) &value, sizeof (new->assign));
819 return new;
820}
821
822/* Handle PROVIDE. */
823
824etree_type *
825exp_provide (dst, src)
826 const char *dst;
827 etree_type *src;
828{
829 etree_type *n;
830
831 n = (etree_type *) stat_alloc (sizeof (n->assign));
832 n->assign.type.node_code = '=';
833 n->assign.type.node_class = etree_provide;
834 n->assign.src = src;
835 n->assign.dst = dst;
836 return n;
837}
838
839/* Handle ASSERT. */
840
841etree_type *
842exp_assert (exp, message)
843 etree_type *exp;
844 const char *message;
845{
846 etree_type *n;
847
848 n = (etree_type *) stat_alloc (sizeof (n->assert_s));
849 n->assert_s.type.node_code = '!';
850 n->assert_s.type.node_class = etree_assert;
851 n->assert_s.child = exp;
852 n->assert_s.message = message;
853 return n;
854}
855
856void
857exp_print_tree (tree)
858 etree_type *tree;
859{
860 switch (tree->type.node_class)
861 {
862 case etree_value:
863 minfo ("0x%v", tree->value.value);
864 return;
865 case etree_rel:
866 if (tree->rel.section->owner != NULL)
867 minfo ("%B:", tree->rel.section->owner);
868 minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
869 return;
870 case etree_assign:
871#if 0
872 if (tree->assign.dst->sdefs != (asymbol *) NULL)
873 {
874 fprintf (config.map_file, "%s (%x) ", tree->assign.dst->name,
875 tree->assign.dst->sdefs->value);
876 }
877 else
878 {
879 fprintf (config.map_file, "%s (UNDEFINED)", tree->assign.dst->name);
880 }
881#endif
882 fprintf (config.map_file, "%s", tree->assign.dst);
883 exp_print_token (tree->type.node_code);
884 exp_print_tree (tree->assign.src);
885 break;
886 case etree_provide:
887 case etree_provided:
888 fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
889 exp_print_tree (tree->assign.src);
890 fprintf (config.map_file, ")");
891 break;
892 case etree_binary:
893 fprintf (config.map_file, "(");
894 exp_print_tree (tree->binary.lhs);
895 exp_print_token (tree->type.node_code);
896 exp_print_tree (tree->binary.rhs);
897 fprintf (config.map_file, ")");
898 break;
899 case etree_trinary:
900 exp_print_tree (tree->trinary.cond);
901 fprintf (config.map_file, "?");
902 exp_print_tree (tree->trinary.lhs);
903 fprintf (config.map_file, ":");
904 exp_print_tree (tree->trinary.rhs);
905 break;
906 case etree_unary:
907 exp_print_token (tree->unary.type.node_code);
908 if (tree->unary.child)
909 {
910 fprintf (config.map_file, "(");
911 exp_print_tree (tree->unary.child);
912 fprintf (config.map_file, ")");
913 }
914 break;
915
916 case etree_assert:
917 fprintf (config.map_file, "ASSERT (");
918 exp_print_tree (tree->assert_s.child);
919 fprintf (config.map_file, ", %s)", tree->assert_s.message);
920 break;
921
922 case etree_undef:
923 fprintf (config.map_file, "????????");
924 break;
925 case etree_name:
926 if (tree->type.node_code == NAME)
927 {
928 fprintf (config.map_file, "%s", tree->name.name);
929 }
930 else
931 {
932 exp_print_token (tree->type.node_code);
933 if (tree->name.name)
934 fprintf (config.map_file, "(%s)", tree->name.name);
935 }
936 break;
937 default:
938 FAIL ();
939 break;
940 }
941}
942
943bfd_vma
944exp_get_vma (tree, def, name, allocation_done)
945 etree_type *tree;
946 bfd_vma def;
947 char *name;
948 lang_phase_type allocation_done;
949{
950 etree_value_type r;
951
952 if (tree != NULL)
953 {
954 r = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
955 if (! r.valid_p && name != NULL)
956 einfo (_("%F%S nonconstant expression for %s\n"), name);
957 return r.value;
958 }
959 else
960 return def;
961}
962
963int
964exp_get_value_int (tree, def, name, allocation_done)
965 etree_type *tree;
966 int def;
967 char *name;
968 lang_phase_type allocation_done;
969{
970 return (int) exp_get_vma (tree, (bfd_vma) def, name, allocation_done);
971}
972
973bfd_vma
974exp_get_abs_int (tree, def, name, allocation_done)
975 etree_type *tree;
976 int def ATTRIBUTE_UNUSED;
977 char *name;
978 lang_phase_type allocation_done;
979{
980 etree_value_type res;
981 res = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
982
983 if (res.valid_p)
984 {
985 res.value += res.section->bfd_section->vma;
986 }
987 else
988 {
989 einfo (_("%F%S non constant expression for %s\n"), name);
990 }
991 return res.value;
992}
Note: See TracBrowser for help on using the repository browser.