daily update
[binutils/dougsmingw.git] / ld / ldexp.c
blob7fdf7f40587d16bd0ff6f98f5f446c3c2a725a7d
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
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
30 valid bit. */
32 #include "sysdep.h"
33 #include "bfd.h"
34 #include "bfdlink.h"
36 #include "ld.h"
37 #include "ldmain.h"
38 #include "ldmisc.h"
39 #include "ldexp.h"
40 #include "ldlex.h"
41 #include <ldgram.h>
42 #include "ldlang.h"
43 #include "libiberty.h"
44 #include "safe-ctype.h"
46 static void exp_fold_tree_1 (etree_type *);
47 static void exp_fold_tree_no_dot (etree_type *);
48 static bfd_vma align_n (bfd_vma, bfd_vma);
50 segment_type *segments;
52 struct ldexp_control expld;
54 /* Print the string representation of the given token. Surround it
55 with spaces if INFIX_P is TRUE. */
57 static void
58 exp_print_token (token_code_type code, int infix_p)
60 static const struct
62 token_code_type code;
63 char * name;
65 table[] =
67 { INT, "int" },
68 { NAME, "NAME" },
69 { PLUSEQ, "+=" },
70 { MINUSEQ, "-=" },
71 { MULTEQ, "*=" },
72 { DIVEQ, "/=" },
73 { LSHIFTEQ, "<<=" },
74 { RSHIFTEQ, ">>=" },
75 { ANDEQ, "&=" },
76 { OREQ, "|=" },
77 { OROR, "||" },
78 { ANDAND, "&&" },
79 { EQ, "==" },
80 { NE, "!=" },
81 { LE, "<=" },
82 { GE, ">=" },
83 { LSHIFT, "<<" },
84 { RSHIFT, ">>" },
85 { ALIGN_K, "ALIGN" },
86 { BLOCK, "BLOCK" },
87 { QUAD, "QUAD" },
88 { SQUAD, "SQUAD" },
89 { LONG, "LONG" },
90 { SHORT, "SHORT" },
91 { BYTE, "BYTE" },
92 { SECTIONS, "SECTIONS" },
93 { SIZEOF_HEADERS, "SIZEOF_HEADERS" },
94 { MEMORY, "MEMORY" },
95 { DEFINED, "DEFINED" },
96 { TARGET_K, "TARGET" },
97 { SEARCH_DIR, "SEARCH_DIR" },
98 { MAP, "MAP" },
99 { ENTRY, "ENTRY" },
100 { NEXT, "NEXT" },
101 { ALIGNOF, "ALIGNOF" },
102 { SIZEOF, "SIZEOF" },
103 { ADDR, "ADDR" },
104 { LOADADDR, "LOADADDR" },
105 { CONSTANT, "CONSTANT" },
106 { ABSOLUTE, "ABSOLUTE" },
107 { MAX_K, "MAX" },
108 { MIN_K, "MIN" },
109 { ASSERT_K, "ASSERT" },
110 { REL, "relocatable" },
111 { DATA_SEGMENT_ALIGN, "DATA_SEGMENT_ALIGN" },
112 { DATA_SEGMENT_RELRO_END, "DATA_SEGMENT_RELRO_END" },
113 { DATA_SEGMENT_END, "DATA_SEGMENT_END" },
114 { ORIGIN, "ORIGIN" },
115 { LENGTH, "LENGTH" },
116 { SEGMENT_START, "SEGMENT_START" }
118 unsigned int idx;
120 for (idx = 0; idx < ARRAY_SIZE (table); idx++)
121 if (table[idx].code == code)
122 break;
124 if (infix_p)
125 fputc (' ', config.map_file);
127 if (idx < ARRAY_SIZE (table))
128 fputs (table[idx].name, config.map_file);
129 else if (code < 127)
130 fputc (code, config.map_file);
131 else
132 fprintf (config.map_file, "<code %d>", code);
134 if (infix_p)
135 fputc (' ', config.map_file);
138 static void
139 make_abs (void)
141 expld.result.value += expld.result.section->vma;
142 expld.result.section = bfd_abs_section_ptr;
145 static void
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;
154 etree_type *
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;
163 return new_e;
166 etree_type *
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;
175 return new_e;
178 /* Build an expression representing an unnamed relocatable value. */
180 etree_type *
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;
189 return new_e;
192 static void
193 new_rel (bfd_vma value, char *str, asection *section)
195 expld.result.valid_p = TRUE;
196 expld.result.value = value;
197 expld.result.str = str;
198 expld.result.section = section;
201 static void
202 new_rel_from_abs (bfd_vma value)
204 expld.result.valid_p = TRUE;
205 expld.result.value = value - expld.section->vma;
206 expld.result.str = NULL;
207 expld.result.section = expld.section;
210 static void
211 fold_unary (etree_type *tree)
213 exp_fold_tree_1 (tree->unary.child);
214 if (expld.result.valid_p)
216 switch (tree->type.node_code)
218 case ALIGN_K:
219 if (expld.phase != lang_first_phase_enum)
220 new_rel_from_abs (align_n (expld.dot, expld.result.value));
221 else
222 expld.result.valid_p = FALSE;
223 break;
225 case ABSOLUTE:
226 make_abs ();
227 break;
229 case '~':
230 make_abs ();
231 expld.result.value = ~expld.result.value;
232 break;
234 case '!':
235 make_abs ();
236 expld.result.value = !expld.result.value;
237 break;
239 case '-':
240 make_abs ();
241 expld.result.value = -expld.result.value;
242 break;
244 case NEXT:
245 /* Return next place aligned to value. */
246 if (expld.phase != lang_first_phase_enum)
248 make_abs ();
249 expld.result.value = align_n (expld.dot, expld.result.value);
251 else
252 expld.result.valid_p = FALSE;
253 break;
255 case DATA_SEGMENT_END:
256 if (expld.phase != lang_first_phase_enum
257 && expld.section == bfd_abs_section_ptr
258 && (expld.dataseg.phase == exp_dataseg_align_seen
259 || expld.dataseg.phase == exp_dataseg_relro_seen
260 || expld.dataseg.phase == exp_dataseg_adjust
261 || expld.dataseg.phase == exp_dataseg_relro_adjust
262 || expld.phase == lang_final_phase_enum))
264 if (expld.dataseg.phase == exp_dataseg_align_seen
265 || expld.dataseg.phase == exp_dataseg_relro_seen)
267 expld.dataseg.phase = exp_dataseg_end_seen;
268 expld.dataseg.end = expld.result.value;
271 else
272 expld.result.valid_p = FALSE;
273 break;
275 default:
276 FAIL ();
277 break;
282 static void
283 fold_binary (etree_type *tree)
285 etree_value_type lhs;
286 exp_fold_tree_1 (tree->binary.lhs);
288 /* The SEGMENT_START operator is special because its first
289 operand is a string, not the name of a symbol. Note that the
290 operands have been swapped, so binary.lhs is second (default)
291 operand, binary.rhs is first operand. */
292 if (expld.result.valid_p && tree->type.node_code == SEGMENT_START)
294 const char *segment_name;
295 segment_type *seg;
296 /* Check to see if the user has overridden the default
297 value. */
298 segment_name = tree->binary.rhs->name.name;
299 for (seg = segments; seg; seg = seg->next)
300 if (strcmp (seg->name, segment_name) == 0)
302 seg->used = TRUE;
303 expld.result.value = seg->value;
304 expld.result.str = NULL;
305 expld.result.section = expld.section;
306 break;
308 return;
311 lhs = expld.result;
312 exp_fold_tree_1 (tree->binary.rhs);
313 expld.result.valid_p &= lhs.valid_p;
315 if (expld.result.valid_p)
317 /* If the values are from different sections, or this is an
318 absolute expression, make both the source arguments
319 absolute. However, adding or subtracting an absolute
320 value from a relative value is meaningful, and is an
321 exception. */
322 if (expld.section != bfd_abs_section_ptr
323 && lhs.section == bfd_abs_section_ptr
324 && tree->type.node_code == '+')
326 /* Keep the section of the rhs term. */
327 expld.result.value = lhs.value + expld.result.value;
328 return;
330 else if (expld.section != bfd_abs_section_ptr
331 && expld.result.section == bfd_abs_section_ptr
332 && (tree->type.node_code == '+'
333 || tree->type.node_code == '-'))
335 /* Keep the section of the lhs term. */
336 expld.result.section = lhs.section;
338 else if (expld.result.section != lhs.section
339 || expld.section == bfd_abs_section_ptr)
341 make_abs ();
342 lhs.value += lhs.section->vma;
345 switch (tree->type.node_code)
347 case '%':
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"));
353 break;
355 case '/':
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"));
361 break;
363 #define BOP(x, y) \
364 case x: \
365 expld.result.value = lhs.value y expld.result.value; \
366 break;
368 BOP ('+', +);
369 BOP ('*', *);
370 BOP ('-', -);
371 BOP (LSHIFT, <<);
372 BOP (RSHIFT, >>);
373 BOP (EQ, ==);
374 BOP (NE, !=);
375 BOP ('<', <);
376 BOP ('>', >);
377 BOP (LE, <=);
378 BOP (GE, >=);
379 BOP ('&', &);
380 BOP ('^', ^);
381 BOP ('|', |);
382 BOP (ANDAND, &&);
383 BOP (OROR, ||);
385 case MAX_K:
386 if (lhs.value > expld.result.value)
387 expld.result.value = lhs.value;
388 break;
390 case MIN_K:
391 if (lhs.value < expld.result.value)
392 expld.result.value = lhs.value;
393 break;
395 case ALIGN_K:
396 expld.result.value = align_n (lhs.value, expld.result.value);
397 break;
399 case DATA_SEGMENT_ALIGN:
400 expld.dataseg.relro = exp_dataseg_relro_start;
401 if (expld.phase != lang_first_phase_enum
402 && expld.section == bfd_abs_section_ptr
403 && (expld.dataseg.phase == exp_dataseg_none
404 || expld.dataseg.phase == exp_dataseg_adjust
405 || expld.dataseg.phase == exp_dataseg_relro_adjust
406 || expld.phase == lang_final_phase_enum))
408 bfd_vma maxpage = lhs.value;
409 bfd_vma commonpage = expld.result.value;
411 expld.result.value = align_n (expld.dot, maxpage);
412 if (expld.dataseg.phase == exp_dataseg_relro_adjust)
413 expld.result.value = expld.dataseg.base;
414 else if (expld.dataseg.phase != exp_dataseg_adjust)
416 expld.result.value += expld.dot & (maxpage - 1);
417 if (expld.phase == lang_allocating_phase_enum)
419 expld.dataseg.phase = exp_dataseg_align_seen;
420 expld.dataseg.min_base = expld.dot;
421 expld.dataseg.base = expld.result.value;
422 expld.dataseg.pagesize = commonpage;
423 expld.dataseg.maxpagesize = maxpage;
424 expld.dataseg.relro_end = 0;
427 else if (commonpage < maxpage)
428 expld.result.value += ((expld.dot + commonpage - 1)
429 & (maxpage - commonpage));
431 else
432 expld.result.valid_p = FALSE;
433 break;
435 case DATA_SEGMENT_RELRO_END:
436 expld.dataseg.relro = exp_dataseg_relro_end;
437 if (expld.phase != lang_first_phase_enum
438 && (expld.dataseg.phase == exp_dataseg_align_seen
439 || expld.dataseg.phase == exp_dataseg_adjust
440 || expld.dataseg.phase == exp_dataseg_relro_adjust
441 || expld.phase == lang_final_phase_enum))
443 if (expld.dataseg.phase == exp_dataseg_align_seen
444 || expld.dataseg.phase == exp_dataseg_relro_adjust)
445 expld.dataseg.relro_end = lhs.value + expld.result.value;
447 if (expld.dataseg.phase == exp_dataseg_relro_adjust
448 && (expld.dataseg.relro_end
449 & (expld.dataseg.pagesize - 1)))
451 expld.dataseg.relro_end += expld.dataseg.pagesize - 1;
452 expld.dataseg.relro_end &= ~(expld.dataseg.pagesize - 1);
453 expld.result.value = (expld.dataseg.relro_end
454 - expld.result.value);
456 else
457 expld.result.value = lhs.value;
459 if (expld.dataseg.phase == exp_dataseg_align_seen)
460 expld.dataseg.phase = exp_dataseg_relro_seen;
462 else
463 expld.result.valid_p = FALSE;
464 break;
466 default:
467 FAIL ();
472 static void
473 fold_trinary (etree_type *tree)
475 exp_fold_tree_1 (tree->trinary.cond);
476 if (expld.result.valid_p)
477 exp_fold_tree_1 (expld.result.value
478 ? tree->trinary.lhs
479 : tree->trinary.rhs);
482 static void
483 fold_name (etree_type *tree)
485 memset (&expld.result, 0, sizeof (expld.result));
487 switch (tree->type.node_code)
489 case SIZEOF_HEADERS:
490 if (expld.phase != lang_first_phase_enum)
492 bfd_vma hdr_size = 0;
493 /* Don't find the real header size if only marking sections;
494 The bfd function may cache incorrect data. */
495 if (expld.phase != lang_mark_phase_enum)
496 hdr_size = bfd_sizeof_headers (link_info.output_bfd, &link_info);
497 new_abs (hdr_size);
499 break;
501 case DEFINED:
502 if (expld.phase == lang_first_phase_enum)
503 lang_track_definedness (tree->name.name);
504 else
506 struct bfd_link_hash_entry *h;
507 int def_iteration
508 = lang_symbol_definition_iteration (tree->name.name);
510 h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
511 &link_info,
512 tree->name.name,
513 FALSE, FALSE, TRUE);
514 expld.result.value = (h != NULL
515 && (h->type == bfd_link_hash_defined
516 || h->type == bfd_link_hash_defweak
517 || h->type == bfd_link_hash_common)
518 && (def_iteration == lang_statement_iteration
519 || def_iteration == -1));
520 expld.result.section = expld.section;
521 expld.result.valid_p = TRUE;
523 break;
525 case NAME:
526 if (expld.phase == lang_first_phase_enum)
528 else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
529 new_rel_from_abs (expld.dot);
530 else
532 struct bfd_link_hash_entry *h;
534 h = bfd_wrapped_link_hash_lookup (link_info.output_bfd,
535 &link_info,
536 tree->name.name,
537 TRUE, FALSE, TRUE);
538 if (!h)
539 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
540 else if (h->type == bfd_link_hash_defined
541 || h->type == bfd_link_hash_defweak)
543 if (bfd_is_abs_section (h->u.def.section))
544 new_abs (h->u.def.value);
545 else
547 asection *output_section;
549 output_section = h->u.def.section->output_section;
550 if (output_section == NULL)
552 if (expld.phase != lang_mark_phase_enum)
553 einfo (_("%X%S: unresolvable symbol `%s'"
554 " referenced in expression\n"),
555 tree->name.name);
557 else
558 new_rel (h->u.def.value + h->u.def.section->output_offset,
559 NULL, output_section);
562 else if (expld.phase == lang_final_phase_enum
563 || expld.assigning_to_dot)
564 einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
565 tree->name.name);
566 else if (h->type == bfd_link_hash_new)
568 h->type = bfd_link_hash_undefined;
569 h->u.undef.abfd = NULL;
570 if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
571 bfd_link_add_undef (link_info.hash, h);
574 break;
576 case ADDR:
577 if (expld.phase != lang_first_phase_enum)
579 lang_output_section_statement_type *os;
581 os = lang_output_section_find (tree->name.name);
582 if (os == NULL)
584 if (expld.phase == lang_final_phase_enum)
585 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
586 tree->name.name);
588 else if (os->processed_vma)
589 new_rel (0, NULL, os->bfd_section);
591 break;
593 case LOADADDR:
594 if (expld.phase != lang_first_phase_enum)
596 lang_output_section_statement_type *os;
598 os = lang_output_section_find (tree->name.name);
599 if (os == NULL)
601 if (expld.phase == lang_final_phase_enum)
602 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
603 tree->name.name);
605 else if (os->processed_lma)
607 if (os->load_base == NULL)
608 new_abs (os->bfd_section->lma);
609 else
611 exp_fold_tree_1 (os->load_base);
612 if (expld.result.valid_p)
613 make_abs ();
617 break;
619 case SIZEOF:
620 case ALIGNOF:
621 if (expld.phase != lang_first_phase_enum)
623 lang_output_section_statement_type *os;
625 os = lang_output_section_find (tree->name.name);
626 if (os == NULL)
628 if (expld.phase == lang_final_phase_enum)
629 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
630 tree->name.name);
631 new_abs (0);
633 else if (os->processed_vma)
635 bfd_vma val;
637 if (tree->type.node_code == SIZEOF)
638 val = (os->bfd_section->size
639 / bfd_octets_per_byte (link_info.output_bfd));
640 else
641 val = (bfd_vma)1 << os->bfd_section->alignment_power;
643 new_abs (val);
646 break;
648 case LENGTH:
650 lang_memory_region_type *mem;
652 mem = lang_memory_region_lookup (tree->name.name, FALSE);
653 if (mem != NULL)
654 new_abs (mem->length);
655 else
656 einfo (_("%F%S: undefined MEMORY region `%s'"
657 " referenced in expression\n"), tree->name.name);
659 break;
661 case ORIGIN:
663 lang_memory_region_type *mem;
665 mem = lang_memory_region_lookup (tree->name.name, FALSE);
666 if (mem != NULL)
667 new_abs (mem->origin);
668 else
669 einfo (_("%F%S: undefined MEMORY region `%s'"
670 " referenced in expression\n"), tree->name.name);
672 break;
674 case CONSTANT:
675 if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
676 new_abs (config.maxpagesize);
677 else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
678 new_abs (config.commonpagesize);
679 else
680 einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
681 tree->name.name);
682 break;
684 default:
685 FAIL ();
686 break;
690 static void
691 exp_fold_tree_1 (etree_type *tree)
693 if (tree == NULL)
695 memset (&expld.result, 0, sizeof (expld.result));
696 return;
699 switch (tree->type.node_class)
701 case etree_value:
702 new_rel (tree->value.value, tree->value.str, expld.section);
703 break;
705 case etree_rel:
706 if (expld.phase != lang_first_phase_enum)
708 asection *output_section = tree->rel.section->output_section;
709 new_rel (tree->rel.value + tree->rel.section->output_offset,
710 NULL, output_section);
712 else
713 memset (&expld.result, 0, sizeof (expld.result));
714 break;
716 case etree_assert:
717 exp_fold_tree_1 (tree->assert_s.child);
718 if (expld.phase == lang_final_phase_enum && !expld.result.value)
719 einfo ("%X%P: %s\n", tree->assert_s.message);
720 break;
722 case etree_unary:
723 fold_unary (tree);
724 break;
726 case etree_binary:
727 fold_binary (tree);
728 break;
730 case etree_trinary:
731 fold_trinary (tree);
732 break;
734 case etree_assign:
735 case etree_provide:
736 case etree_provided:
737 if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
739 /* Assignment to dot can only be done during allocation. */
740 if (tree->type.node_class != etree_assign)
741 einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
742 if (expld.phase == lang_mark_phase_enum
743 || expld.phase == lang_allocating_phase_enum
744 || (expld.phase == lang_final_phase_enum
745 && expld.section == bfd_abs_section_ptr))
747 /* Notify the folder that this is an assignment to dot. */
748 expld.assigning_to_dot = TRUE;
749 exp_fold_tree_1 (tree->assign.src);
750 expld.assigning_to_dot = FALSE;
752 if (!expld.result.valid_p)
754 if (expld.phase != lang_mark_phase_enum)
755 einfo (_("%F%S invalid assignment to location counter\n"));
757 else if (expld.dotp == NULL)
758 einfo (_("%F%S assignment to location counter"
759 " invalid outside of SECTION\n"));
760 else
762 bfd_vma nextdot;
764 nextdot = expld.result.value + expld.section->vma;
765 if (nextdot < expld.dot
766 && expld.section != bfd_abs_section_ptr)
767 einfo (_("%F%S cannot move location counter backwards"
768 " (from %V to %V)\n"), expld.dot, nextdot);
769 else
771 expld.dot = nextdot;
772 *expld.dotp = nextdot;
776 else
777 memset (&expld.result, 0, sizeof (expld.result));
779 else
781 struct bfd_link_hash_entry *h = NULL;
783 if (tree->type.node_class == etree_provide)
785 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
786 FALSE, FALSE, TRUE);
787 if (h == NULL
788 || (h->type != bfd_link_hash_new
789 && h->type != bfd_link_hash_undefined
790 && h->type != bfd_link_hash_common))
792 /* Do nothing. The symbol was never referenced, or was
793 defined by some object. */
794 break;
798 exp_fold_tree_1 (tree->assign.src);
799 if (expld.result.valid_p)
801 if (h == NULL)
803 h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
804 TRUE, FALSE, TRUE);
805 if (h == NULL)
806 einfo (_("%P%F:%s: hash creation failed\n"),
807 tree->assign.dst);
810 /* FIXME: Should we worry if the symbol is already
811 defined? */
812 lang_update_definedness (tree->assign.dst, h);
813 h->type = bfd_link_hash_defined;
814 h->u.def.value = expld.result.value;
815 h->u.def.section = expld.result.section;
816 if (tree->type.node_class == etree_provide)
817 tree->type.node_class = etree_provided;
819 /* Copy the symbol type if this is a simple assignment of
820 one symbol to annother. */
821 if (tree->assign.src->type.node_class == etree_name)
823 struct bfd_link_hash_entry *hsrc;
825 hsrc = bfd_link_hash_lookup (link_info.hash,
826 tree->assign.src->name.name,
827 FALSE, FALSE, TRUE);
828 if (hsrc)
829 bfd_copy_link_hash_symbol_type (link_info.output_bfd, h,
830 hsrc);
834 break;
836 case etree_name:
837 fold_name (tree);
838 break;
840 default:
841 FAIL ();
842 memset (&expld.result, 0, sizeof (expld.result));
843 break;
847 void
848 exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
850 expld.dot = *dotp;
851 expld.dotp = dotp;
852 expld.section = current_section;
853 exp_fold_tree_1 (tree);
856 static void
857 exp_fold_tree_no_dot (etree_type *tree)
859 expld.dot = 0;
860 expld.dotp = NULL;
861 expld.section = bfd_abs_section_ptr;
862 exp_fold_tree_1 (tree);
865 etree_type *
866 exp_binop (int code, etree_type *lhs, etree_type *rhs)
868 etree_type value, *new_e;
870 value.type.node_code = code;
871 value.type.lineno = lhs->type.lineno;
872 value.binary.lhs = lhs;
873 value.binary.rhs = rhs;
874 value.type.node_class = etree_binary;
875 exp_fold_tree_no_dot (&value);
876 if (expld.result.valid_p)
877 return exp_intop (expld.result.value);
879 new_e = (etree_type *) stat_alloc (sizeof (new_e->binary));
880 memcpy (new_e, &value, sizeof (new_e->binary));
881 return new_e;
884 etree_type *
885 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
887 etree_type value, *new_e;
889 value.type.node_code = code;
890 value.type.lineno = lhs->type.lineno;
891 value.trinary.lhs = lhs;
892 value.trinary.cond = cond;
893 value.trinary.rhs = rhs;
894 value.type.node_class = etree_trinary;
895 exp_fold_tree_no_dot (&value);
896 if (expld.result.valid_p)
897 return exp_intop (expld.result.value);
899 new_e = (etree_type *) stat_alloc (sizeof (new_e->trinary));
900 memcpy (new_e, &value, sizeof (new_e->trinary));
901 return new_e;
904 etree_type *
905 exp_unop (int code, etree_type *child)
907 etree_type value, *new_e;
909 value.unary.type.node_code = code;
910 value.unary.type.lineno = child->type.lineno;
911 value.unary.child = child;
912 value.unary.type.node_class = etree_unary;
913 exp_fold_tree_no_dot (&value);
914 if (expld.result.valid_p)
915 return exp_intop (expld.result.value);
917 new_e = (etree_type *) stat_alloc (sizeof (new_e->unary));
918 memcpy (new_e, &value, sizeof (new_e->unary));
919 return new_e;
922 etree_type *
923 exp_nameop (int code, const char *name)
925 etree_type value, *new_e;
927 value.name.type.node_code = code;
928 value.name.type.lineno = lineno;
929 value.name.name = name;
930 value.name.type.node_class = etree_name;
932 exp_fold_tree_no_dot (&value);
933 if (expld.result.valid_p)
934 return exp_intop (expld.result.value);
936 new_e = (etree_type *) stat_alloc (sizeof (new_e->name));
937 memcpy (new_e, &value, sizeof (new_e->name));
938 return new_e;
942 etree_type *
943 exp_assop (int code, const char *dst, etree_type *src)
945 etree_type *new_e;
947 new_e = (etree_type *) stat_alloc (sizeof (new_e->assign));
948 new_e->type.node_code = code;
949 new_e->type.lineno = src->type.lineno;
950 new_e->type.node_class = etree_assign;
951 new_e->assign.src = src;
952 new_e->assign.dst = dst;
953 return new_e;
956 /* Handle PROVIDE. */
958 etree_type *
959 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
961 etree_type *n;
963 n = (etree_type *) stat_alloc (sizeof (n->assign));
964 n->assign.type.node_code = '=';
965 n->assign.type.lineno = src->type.lineno;
966 n->assign.type.node_class = etree_provide;
967 n->assign.src = src;
968 n->assign.dst = dst;
969 n->assign.hidden = hidden;
970 return n;
973 /* Handle ASSERT. */
975 etree_type *
976 exp_assert (etree_type *exp, const char *message)
978 etree_type *n;
980 n = (etree_type *) stat_alloc (sizeof (n->assert_s));
981 n->assert_s.type.node_code = '!';
982 n->assert_s.type.lineno = exp->type.lineno;
983 n->assert_s.type.node_class = etree_assert;
984 n->assert_s.child = exp;
985 n->assert_s.message = message;
986 return n;
989 void
990 exp_print_tree (etree_type *tree)
992 if (config.map_file == NULL)
993 config.map_file = stderr;
995 if (tree == NULL)
997 minfo ("NULL TREE\n");
998 return;
1001 switch (tree->type.node_class)
1003 case etree_value:
1004 minfo ("0x%v", tree->value.value);
1005 return;
1006 case etree_rel:
1007 if (tree->rel.section->owner != NULL)
1008 minfo ("%B:", tree->rel.section->owner);
1009 minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
1010 return;
1011 case etree_assign:
1012 fprintf (config.map_file, "%s", tree->assign.dst);
1013 exp_print_token (tree->type.node_code, TRUE);
1014 exp_print_tree (tree->assign.src);
1015 break;
1016 case etree_provide:
1017 case etree_provided:
1018 fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
1019 exp_print_tree (tree->assign.src);
1020 fprintf (config.map_file, ")");
1021 break;
1022 case etree_binary:
1023 fprintf (config.map_file, "(");
1024 exp_print_tree (tree->binary.lhs);
1025 exp_print_token (tree->type.node_code, TRUE);
1026 exp_print_tree (tree->binary.rhs);
1027 fprintf (config.map_file, ")");
1028 break;
1029 case etree_trinary:
1030 exp_print_tree (tree->trinary.cond);
1031 fprintf (config.map_file, "?");
1032 exp_print_tree (tree->trinary.lhs);
1033 fprintf (config.map_file, ":");
1034 exp_print_tree (tree->trinary.rhs);
1035 break;
1036 case etree_unary:
1037 exp_print_token (tree->unary.type.node_code, FALSE);
1038 if (tree->unary.child)
1040 fprintf (config.map_file, " (");
1041 exp_print_tree (tree->unary.child);
1042 fprintf (config.map_file, ")");
1044 break;
1046 case etree_assert:
1047 fprintf (config.map_file, "ASSERT (");
1048 exp_print_tree (tree->assert_s.child);
1049 fprintf (config.map_file, ", %s)", tree->assert_s.message);
1050 break;
1052 case etree_name:
1053 if (tree->type.node_code == NAME)
1055 fprintf (config.map_file, "%s", tree->name.name);
1057 else
1059 exp_print_token (tree->type.node_code, FALSE);
1060 if (tree->name.name)
1061 fprintf (config.map_file, " (%s)", tree->name.name);
1063 break;
1064 default:
1065 FAIL ();
1066 break;
1070 bfd_vma
1071 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1073 if (tree != NULL)
1075 exp_fold_tree_no_dot (tree);
1076 if (expld.result.valid_p)
1077 return expld.result.value;
1078 else if (name != NULL && expld.phase != lang_mark_phase_enum)
1079 einfo (_("%F%S: nonconstant expression for %s\n"), name);
1081 return def;
1085 exp_get_value_int (etree_type *tree, int def, char *name)
1087 return exp_get_vma (tree, def, name);
1090 fill_type *
1091 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1093 fill_type *fill;
1094 size_t len;
1095 unsigned int val;
1097 if (tree == NULL)
1098 return def;
1100 exp_fold_tree_no_dot (tree);
1101 if (!expld.result.valid_p)
1103 if (name != NULL && expld.phase != lang_mark_phase_enum)
1104 einfo (_("%F%S: nonconstant expression for %s\n"), name);
1105 return def;
1108 if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1110 unsigned char *dst;
1111 unsigned char *s;
1112 fill = (fill_type *) xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1113 fill->size = (len + 1) / 2;
1114 dst = fill->data;
1115 s = (unsigned char *) expld.result.str;
1116 val = 0;
1119 unsigned int digit;
1121 digit = *s++ - '0';
1122 if (digit > 9)
1123 digit = (digit - 'A' + '0' + 10) & 0xf;
1124 val <<= 4;
1125 val += digit;
1126 --len;
1127 if ((len & 1) == 0)
1129 *dst++ = val;
1130 val = 0;
1133 while (len != 0);
1135 else
1137 fill = (fill_type *) xmalloc (4 + sizeof (*fill) - 1);
1138 val = expld.result.value;
1139 fill->data[0] = (val >> 24) & 0xff;
1140 fill->data[1] = (val >> 16) & 0xff;
1141 fill->data[2] = (val >> 8) & 0xff;
1142 fill->data[3] = (val >> 0) & 0xff;
1143 fill->size = 4;
1145 return fill;
1148 bfd_vma
1149 exp_get_abs_int (etree_type *tree, int def, char *name)
1151 if (tree != NULL)
1153 exp_fold_tree_no_dot (tree);
1155 if (expld.result.valid_p)
1157 expld.result.value += expld.result.section->vma;
1158 return expld.result.value;
1160 else if (name != NULL && expld.phase != lang_mark_phase_enum)
1162 lineno = tree->type.lineno;
1163 einfo (_("%F%S: nonconstant expression for %s\n"), name);
1166 return def;
1169 static bfd_vma
1170 align_n (bfd_vma value, bfd_vma align)
1172 if (align <= 1)
1173 return value;
1175 value = (value + align - 1) / align;
1176 return value * align;