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