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