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