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