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 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 (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 (output_bfd, &link_info,
 507                                             tree->name.name,
 508                                             FALSE, FALSE, TRUE);
 509           expld.result.value = (h != NULL
 510                                 && (h->type == bfd_link_hash_defined
 511                                     || h->type == bfd_link_hash_defweak
 512                                     || h->type == bfd_link_hash_common)
 513                                 && (def_iteration == lang_statement_iteration
 514                                     || def_iteration == -1));
 515           expld.result.section = bfd_abs_section_ptr;
 516           expld.result.valid_p = TRUE;
 517         }
 518       break;
 519
 520     case NAME:
 521       if (expld.phase == lang_first_phase_enum)
 522         ;
 523       else if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
 524         new_rel_from_abs (expld.dot);
 525       else
 526         {
 527           struct bfd_link_hash_entry *h;
 528
 529           h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
 530                                             tree->name.name,
 531                                             TRUE, FALSE, TRUE);
 532           if (!h)
 533             einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
 534           else if (h->type == bfd_link_hash_defined
 535                    || h->type == bfd_link_hash_defweak)
 536             {
 537               if (bfd_is_abs_section (h->u.def.section))
 538                 new_abs (h->u.def.value);
 539               else
 540                 {
 541                   asection *output_section;
 542
 543                   output_section = h->u.def.section->output_section;
 544                   if (output_section == NULL)
 545                     {
 546                       if (expld.phase != lang_mark_phase_enum)
 547                         einfo (_("%X%S: unresolvable symbol `%s'"
 548                                  " referenced in expression\n"),
 549                                tree->name.name);
 550                     }
 551                   else
 552                     new_rel (h->u.def.value + h->u.def.section->output_offset,
 553                              NULL, output_section);
 554                 }
 555             }
 556           else if (expld.phase == lang_final_phase_enum
 557                    || expld.assigning_to_dot)
 558             einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
 559                    tree->name.name);
 560           else if (h->type == bfd_link_hash_new)
 561             {
 562               h->type = bfd_link_hash_undefined;
 563               h->u.undef.abfd = NULL;
 564               if (h->u.undef.next == NULL && h != link_info.hash->undefs_tail)
 565                 bfd_link_add_undef (link_info.hash, h);
 566             }
 567         }
 568       break;
 569
 570     case ADDR:
 571       if (expld.phase != lang_first_phase_enum)
 572         {
 573           lang_output_section_statement_type *os;
 574
 575           os = lang_output_section_find (tree->name.name);
 576           if (os == NULL)
 577             {
 578               if (expld.phase == lang_final_phase_enum)
 579                 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
 580                        tree->name.name);
 581             }
 582           else if (os->processed_vma)
 583             new_rel (0, NULL, os->bfd_section);
 584         }
 585       break;
 586
 587     case LOADADDR:
 588       if (expld.phase != lang_first_phase_enum)
 589         {
 590           lang_output_section_statement_type *os;
 591
 592           os = lang_output_section_find (tree->name.name);
 593           if (os == NULL)
 594             {
 595               if (expld.phase == lang_final_phase_enum)
 596                 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
 597                        tree->name.name);
 598             }
 599           else if (os->processed_lma)
 600             {
 601               if (os->load_base == NULL)
 602                 new_abs (os->bfd_section->lma);
 603               else
 604                 {
 605                   exp_fold_tree_1 (os->load_base);
 606                   make_abs ();
 607                 }
 608             }
 609         }
 610       break;
 611
 612     case SIZEOF:
 613     case ALIGNOF:
 614       if (expld.phase != lang_first_phase_enum)
 615         {
 616           lang_output_section_statement_type *os;
 617
 618           os = lang_output_section_find (tree->name.name);
 619           if (os == NULL)
 620             {
 621               if (expld.phase == lang_final_phase_enum)
 622                 einfo (_("%F%S: undefined section `%s' referenced in expression\n"),
 623                        tree->name.name);
 624               new_abs (0);
 625             }
 626           else if (os->processed_vma)
 627             {
 628               bfd_vma val;
 629
 630               if (tree->type.node_code == SIZEOF)
 631                 val = os->bfd_section->size / bfd_octets_per_byte (output_bfd);
 632               else
 633                 val = (bfd_vma)1 << os->bfd_section->alignment_power;
 634
 635               new_abs (val);
 636             }
 637         }
 638       break;
 639
 640     case LENGTH:
 641       {
 642         lang_memory_region_type *mem;
 643
 644         mem = lang_memory_region_lookup (tree->name.name, FALSE);
 645         if (mem != NULL)
 646           new_abs (mem->length);
 647         else
 648           einfo (_("%F%S: undefined MEMORY region `%s'"
 649                    " referenced in expression\n"), tree->name.name);
 650       }
 651       break;
 652
 653     case ORIGIN:
 654       {
 655         lang_memory_region_type *mem;
 656
 657         mem = lang_memory_region_lookup (tree->name.name, FALSE);
 658         if (mem != NULL)
 659           new_abs (mem->origin);
 660         else
 661           einfo (_("%F%S: undefined MEMORY region `%s'"
 662                    " referenced in expression\n"), tree->name.name);
 663       }
 664       break;
 665
 666     case CONSTANT:
 667       if (strcmp (tree->name.name, "MAXPAGESIZE") == 0)
 668         new_abs (bfd_emul_get_maxpagesize (default_target));
 669       else if (strcmp (tree->name.name, "COMMONPAGESIZE") == 0)
 670         new_abs (bfd_emul_get_commonpagesize (default_target));
 671       else
 672         einfo (_("%F%S: unknown constant `%s' referenced in expression\n"),
 673                tree->name.name);
 674       break;
 675
 676     default:
 677       FAIL ();
 678       break;
 679     }
 680 }
 681
 682 static void
 683 exp_fold_tree_1 (etree_type *tree)
 684 {
 685   if (tree == NULL)
 686     {
 687       memset (&expld.result, 0, sizeof (expld.result));
 688       return;
 689     }
 690
 691   switch (tree->type.node_class)
 692     {
 693     case etree_value:
 694       new_rel (tree->value.value, tree->value.str, expld.section);
 695       break;
 696
 697     case etree_rel:
 698       if (expld.phase != lang_first_phase_enum)
 699         {
 700           asection *output_section = tree->rel.section->output_section;
 701           new_rel (tree->rel.value + tree->rel.section->output_offset,
 702                    NULL, output_section);
 703         }
 704       else
 705         memset (&expld.result, 0, sizeof (expld.result));
 706       break;
 707
 708     case etree_assert:
 709       exp_fold_tree_1 (tree->assert_s.child);
 710       if (expld.phase == lang_final_phase_enum && !expld.result.value)
 711         einfo ("%X%P: %s\n", tree->assert_s.message);
 712       break;
 713
 714     case etree_unary:
 715       fold_unary (tree);
 716       break;
 717
 718     case etree_binary:
 719       fold_binary (tree);
 720       break;
 721
 722     case etree_trinary:
 723       fold_trinary (tree);
 724       break;
 725
 726     case etree_assign:
 727     case etree_provide:
 728     case etree_provided:
 729       if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
 730         {
 731           /* Assignment to dot can only be done during allocation.  */
 732           if (tree->type.node_class != etree_assign)
 733             einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
 734           if (expld.phase == lang_mark_phase_enum
 735               || expld.phase == lang_allocating_phase_enum
 736               || (expld.phase == lang_final_phase_enum
 737                   && expld.section == bfd_abs_section_ptr))
 738             {
 739               /* Notify the folder that this is an assignment to dot.  */
 740               expld.assigning_to_dot = TRUE;
 741               exp_fold_tree_1 (tree->assign.src);
 742               expld.assigning_to_dot = FALSE;
 743
 744               if (!expld.result.valid_p)
 745                 {
 746                   if (expld.phase != lang_mark_phase_enum)
 747                     einfo (_("%F%S invalid assignment to location counter\n"));
 748                 }
 749               else if (expld.dotp == NULL)
 750                 einfo (_("%F%S assignment to location counter"
 751                          " invalid outside of SECTION\n"));
 752               else
 753                 {
 754                   bfd_vma nextdot;
 755
 756                   nextdot = expld.result.value + expld.section->vma;
 757                   if (nextdot < expld.dot
 758                       && expld.section != bfd_abs_section_ptr)
 759                     einfo (_("%F%S cannot move location counter backwards"
 760                              " (from %V to %V)\n"), expld.dot, nextdot);
 761                   else
 762                     {
 763                       expld.dot = nextdot;
 764                       *expld.dotp = nextdot;
 765                     }
 766                 }
 767             }
 768           else
 769             memset (&expld.result, 0, sizeof (expld.result));
 770         }
 771       else
 772         {
 773           struct bfd_link_hash_entry *h = NULL;
 774
 775           if (tree->type.node_class == etree_provide)
 776             {
 777               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
 778                                         FALSE, FALSE, TRUE);
 779               if (h == NULL
 780                   || (h->type != bfd_link_hash_new
 781                       && h->type != bfd_link_hash_undefined
 782                       && h->type != bfd_link_hash_common))
 783                 {
 784                   /* Do nothing.  The symbol was never referenced, or was
 785                      defined by some object.  */
 786                   break;
 787                 }
 788             }
 789
 790           exp_fold_tree_1 (tree->assign.src);
 791           if (expld.result.valid_p)
 792             {
 793               if (h == NULL)
 794                 {
 795                   h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
 796                                             TRUE, FALSE, TRUE);
 797                   if (h == NULL)
 798                     einfo (_("%P%F:%s: hash creation failed\n"),
 799                            tree->assign.dst);
 800                 }
 801
 802               /* FIXME: Should we worry if the symbol is already
 803                  defined?  */
 804               lang_update_definedness (tree->assign.dst, h);
 805               h->type = bfd_link_hash_defined;
 806               h->u.def.value = expld.result.value;
 807               h->u.def.section = expld.result.section;
 808               if (tree->type.node_class == etree_provide)
 809                 tree->type.node_class = etree_provided;
 810             }
 811         }
 812       break;
 813
 814     case etree_name:
 815       fold_name (tree);
 816       break;
 817
 818     default:
 819       FAIL ();
 820       memset (&expld.result, 0, sizeof (expld.result));
 821       break;
 822     }
 823 }
 824
 825 void
 826 exp_fold_tree (etree_type *tree, asection *current_section, bfd_vma *dotp)
 827 {
 828   expld.dot = *dotp;
 829   expld.dotp = dotp;
 830   expld.section = current_section;
 831   exp_fold_tree_1 (tree);
 832 }
 833
 834 static void
 835 exp_fold_tree_no_dot (etree_type *tree)
 836 {
 837   expld.dot = 0;
 838   expld.dotp = NULL;
 839   expld.section = bfd_abs_section_ptr;
 840   exp_fold_tree_1 (tree);
 841 }
 842
 843 etree_type *
 844 exp_binop (int code, etree_type *lhs, etree_type *rhs)
 845 {
 846   etree_type value, *new;
 847
 848   value.type.node_code = code;
 849   value.type.lineno = lhs->type.lineno;
 850   value.binary.lhs = lhs;
 851   value.binary.rhs = rhs;
 852   value.type.node_class = etree_binary;
 853   exp_fold_tree_no_dot (&value);
 854   if (expld.result.valid_p)
 855     return exp_intop (expld.result.value);
 856
 857   new = stat_alloc (sizeof (new->binary));
 858   memcpy (new, &value, sizeof (new->binary));
 859   return new;
 860 }
 861
 862 etree_type *
 863 exp_trinop (int code, etree_type *cond, etree_type *lhs, etree_type *rhs)
 864 {
 865   etree_type value, *new;
 866
 867   value.type.node_code = code;
 868   value.type.lineno = lhs->type.lineno;
 869   value.trinary.lhs = lhs;
 870   value.trinary.cond = cond;
 871   value.trinary.rhs = rhs;
 872   value.type.node_class = etree_trinary;
 873   exp_fold_tree_no_dot (&value);
 874   if (expld.result.valid_p)
 875     return exp_intop (expld.result.value);
 876
 877   new = stat_alloc (sizeof (new->trinary));
 878   memcpy (new, &value, sizeof (new->trinary));
 879   return new;
 880 }
 881
 882 etree_type *
 883 exp_unop (int code, etree_type *child)
 884 {
 885   etree_type value, *new;
 886
 887   value.unary.type.node_code = code;
 888   value.unary.type.lineno = child->type.lineno;
 889   value.unary.child = child;
 890   value.unary.type.node_class = etree_unary;
 891   exp_fold_tree_no_dot (&value);
 892   if (expld.result.valid_p)
 893     return exp_intop (expld.result.value);
 894
 895   new = stat_alloc (sizeof (new->unary));
 896   memcpy (new, &value, sizeof (new->unary));
 897   return new;
 898 }
 899
 900 etree_type *
 901 exp_nameop (int code, const char *name)
 902 {
 903   etree_type value, *new;
 904
 905   value.name.type.node_code = code;
 906   value.name.type.lineno = lineno;
 907   value.name.name = name;
 908   value.name.type.node_class = etree_name;
 909
 910   exp_fold_tree_no_dot (&value);
 911   if (expld.result.valid_p)
 912     return exp_intop (expld.result.value);
 913
 914   new = stat_alloc (sizeof (new->name));
 915   memcpy (new, &value, sizeof (new->name));
 916   return new;
 917
 918 }
 919
 920 etree_type *
 921 exp_assop (int code, const char *dst, etree_type *src)
 922 {
 923   etree_type *new;
 924
 925   new = stat_alloc (sizeof (new->assign));
 926   new->type.node_code = code;
 927   new->type.lineno = src->type.lineno;
 928   new->type.node_class = etree_assign;
 929   new->assign.src = src;
 930   new->assign.dst = dst;
 931   return new;
 932 }
 933
 934 /* Handle PROVIDE.  */
 935
 936 etree_type *
 937 exp_provide (const char *dst, etree_type *src, bfd_boolean hidden)
 938 {
 939   etree_type *n;
 940
 941   n = stat_alloc (sizeof (n->assign));
 942   n->assign.type.node_code = '=';
 943   n->assign.type.lineno = src->type.lineno;
 944   n->assign.type.node_class = etree_provide;
 945   n->assign.src = src;
 946   n->assign.dst = dst;
 947   n->assign.hidden = hidden;
 948   return n;
 949 }
 950
 951 /* Handle ASSERT.  */
 952
 953 etree_type *
 954 exp_assert (etree_type *exp, const char *message)
 955 {
 956   etree_type *n;
 957
 958   n = stat_alloc (sizeof (n->assert_s));
 959   n->assert_s.type.node_code = '!';
 960   n->assert_s.type.lineno = exp->type.lineno;
 961   n->assert_s.type.node_class = etree_assert;
 962   n->assert_s.child = exp;
 963   n->assert_s.message = message;
 964   return n;
 965 }
 966
 967 void
 968 exp_print_tree (etree_type *tree)
 969 {
 970   if (config.map_file == NULL)
 971     config.map_file = stderr;
 972
 973   if (tree == NULL)
 974     {
 975       minfo ("NULL TREE\n");
 976       return;
 977     }
 978
 979   switch (tree->type.node_class)
 980     {
 981     case etree_value:
 982       minfo ("0x%v", tree->value.value);
 983       return;
 984     case etree_rel:
 985       if (tree->rel.section->owner != NULL)
 986         minfo ("%B:", tree->rel.section->owner);
 987       minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
 988       return;
 989     case etree_assign:
 990       fprintf (config.map_file, "%s", tree->assign.dst);
 991       exp_print_token (tree->type.node_code, TRUE);
 992       exp_print_tree (tree->assign.src);
 993       break;
 994     case etree_provide:
 995     case etree_provided:
 996       fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
 997       exp_print_tree (tree->assign.src);
 998       fprintf (config.map_file, ")");
 999       break;
1000     case etree_binary:
1001       fprintf (config.map_file, "(");
1002       exp_print_tree (tree->binary.lhs);
1003       exp_print_token (tree->type.node_code, TRUE);
1004       exp_print_tree (tree->binary.rhs);
1005       fprintf (config.map_file, ")");
1006       break;
1007     case etree_trinary:
1008       exp_print_tree (tree->trinary.cond);
1009       fprintf (config.map_file, "?");
1010       exp_print_tree (tree->trinary.lhs);
1011       fprintf (config.map_file, ":");
1012       exp_print_tree (tree->trinary.rhs);
1013       break;
1014     case etree_unary:
1015       exp_print_token (tree->unary.type.node_code, FALSE);
1016       if (tree->unary.child)
1017         {
1018           fprintf (config.map_file, " (");
1019           exp_print_tree (tree->unary.child);
1020           fprintf (config.map_file, ")");
1021         }
1022       break;
1023
1024     case etree_assert:
1025       fprintf (config.map_file, "ASSERT (");
1026       exp_print_tree (tree->assert_s.child);
1027       fprintf (config.map_file, ", %s)", tree->assert_s.message);
1028       break;
1029
1030     case etree_name:
1031       if (tree->type.node_code == NAME)
1032         {
1033           fprintf (config.map_file, "%s", tree->name.name);
1034         }
1035       else
1036         {
1037           exp_print_token (tree->type.node_code, FALSE);
1038           if (tree->name.name)
1039             fprintf (config.map_file, " (%s)", tree->name.name);
1040         }
1041       break;
1042     default:
1043       FAIL ();
1044       break;
1045     }
1046 }
1047
1048 bfd_vma
1049 exp_get_vma (etree_type *tree, bfd_vma def, char *name)
1050 {
1051   if (tree != NULL)
1052     {
1053       exp_fold_tree_no_dot (tree);
1054       if (expld.result.valid_p)
1055         return expld.result.value;
1056       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1057         einfo (_("%F%S: nonconstant expression for %s\n"), name);
1058     }
1059   return def;
1060 }
1061
1062 int
1063 exp_get_value_int (etree_type *tree, int def, char *name)
1064 {
1065   return exp_get_vma (tree, def, name);
1066 }
1067
1068 fill_type *
1069 exp_get_fill (etree_type *tree, fill_type *def, char *name)
1070 {
1071   fill_type *fill;
1072   size_t len;
1073   unsigned int val;
1074
1075   if (tree == NULL)
1076     return def;
1077
1078   exp_fold_tree_no_dot (tree);
1079   if (!expld.result.valid_p)
1080     {
1081       if (name != NULL && expld.phase != lang_mark_phase_enum)
1082         einfo (_("%F%S: nonconstant expression for %s\n"), name);
1083       return def;
1084     }
1085
1086   if (expld.result.str != NULL && (len = strlen (expld.result.str)) != 0)
1087     {
1088       unsigned char *dst;
1089       unsigned char *s;
1090       fill = xmalloc ((len + 1) / 2 + sizeof (*fill) - 1);
1091       fill->size = (len + 1) / 2;
1092       dst = fill->data;
1093       s = (unsigned char *) expld.result.str;
1094       val = 0;
1095       do
1096         {
1097           unsigned int digit;
1098
1099           digit = *s++ - '0';
1100           if (digit > 9)
1101             digit = (digit - 'A' + '0' + 10) & 0xf;
1102           val <<= 4;
1103           val += digit;
1104           --len;
1105           if ((len & 1) == 0)
1106             {
1107               *dst++ = val;
1108               val = 0;
1109             }
1110         }
1111       while (len != 0);
1112     }
1113   else
1114     {
1115       fill = xmalloc (4 + sizeof (*fill) - 1);
1116       val = expld.result.value;
1117       fill->data[0] = (val >> 24) & 0xff;
1118       fill->data[1] = (val >> 16) & 0xff;
1119       fill->data[2] = (val >>  8) & 0xff;
1120       fill->data[3] = (val >>  0) & 0xff;
1121       fill->size = 4;
1122     }
1123   return fill;
1124 }
1125
1126 bfd_vma
1127 exp_get_abs_int (etree_type *tree, int def, char *name)
1128 {
1129   if (tree != NULL)
1130     {
1131       exp_fold_tree_no_dot (tree);
1132
1133       if (expld.result.valid_p)
1134         {
1135           expld.result.value += expld.result.section->vma;
1136           return expld.result.value;
1137         }
1138       else if (name != NULL && expld.phase != lang_mark_phase_enum)
1139         {
1140           lineno = tree->type.lineno;
1141           einfo (_("%F%S: nonconstant expression for %s\n"), name);
1142         }
1143     }
1144   return def;
1145 }
1146
1147 static bfd_vma
1148 align_n (bfd_vma value, bfd_vma align)
1149 {
1150   if (align <= 1)
1151     return value;
1152
1153   value = (value + align - 1) / align;
1154   return value * align;
1155 }