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