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