ld/ldexp.c

   1 /* This module handles expression trees.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001
   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, 59 Temple Place - Suite 330, Boston, MA
  22 02111-1307, 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
  42 static void exp_print_token PARAMS ((token_code_type code));
  43 static void make_abs PARAMS ((etree_value_type *ptr));
  44 static etree_value_type new_abs PARAMS ((bfd_vma value));
  45 static void check PARAMS ((lang_output_section_statement_type *os,
  46                            const char *name, const char *op));
  47 static etree_value_type new_rel
  48   PARAMS ((bfd_vma value, lang_output_section_statement_type *section));
  49 static etree_value_type new_rel_from_section
  50   PARAMS ((bfd_vma value, lang_output_section_statement_type *section));
  51 static etree_value_type fold_binary
  52   PARAMS ((etree_type *tree,
  53            lang_output_section_statement_type *current_section,
  54            lang_phase_type allocation_done,
  55            bfd_vma dot, bfd_vma *dotp));
  56 static etree_value_type fold_name
  57   PARAMS ((etree_type *tree,
  58            lang_output_section_statement_type *current_section,
  59            lang_phase_type allocation_done,
  60            bfd_vma dot));
  61 static etree_value_type exp_fold_tree_no_dot
  62   PARAMS ((etree_type *tree,
  63            lang_output_section_statement_type *current_section,
  64            lang_phase_type allocation_done));
  65
  66 static void
  67 exp_print_token (code)
  68      token_code_type code;
  69 {
  70   static CONST struct {
  71     token_code_type code;
  72     char *name;
  73   } table[] = {
  74     { INT, "int" },
  75     { REL, "relocateable" },
  76     { NAME, "NAME" },
  77     { PLUSEQ, "+=" },
  78     { MINUSEQ, "-=" },
  79     { MULTEQ, "*=" },
  80     { DIVEQ, "/=" },
  81     { LSHIFTEQ, "<<=" },
  82     { RSHIFTEQ, ">>=" },
  83     { ANDEQ, "&=" },
  84     { OREQ, "|=" },
  85     { OROR, "||" },
  86     { ANDAND, "&&" },
  87     { EQ, "==" },
  88     { NE, "!=" },
  89     { LE, "<=" },
  90     { GE, ">=" },
  91     { LSHIFT, "<<" },
  92     { RSHIFT, ">>=" },
  93     { ALIGN_K, "ALIGN" },
  94     { BLOCK, "BLOCK" },
  95     { SECTIONS, "SECTIONS" },
  96     { SIZEOF_HEADERS, "SIZEOF_HEADERS" },
  97     { NEXT, "NEXT" },
  98     { SIZEOF, "SIZEOF" },
  99     { ADDR, "ADDR" },
 100     { LOADADDR, "LOADADDR" },
 101     { MEMORY, "MEMORY" },
 102     { DEFINED, "DEFINED" },
 103     { TARGET_K, "TARGET" },
 104     { SEARCH_DIR, "SEARCH_DIR" },
 105     { MAP, "MAP" },
 106     { QUAD, "QUAD" },
 107     { SQUAD, "SQUAD" },
 108     { LONG, "LONG" },
 109     { SHORT, "SHORT" },
 110     { BYTE, "BYTE" },
 111     { ENTRY, "ENTRY" },
 112     { 0, (char *) NULL }
 113   };
 114   unsigned int idx;
 115
 116   for (idx = 0; table[idx].name != (char *) NULL; idx++)
 117     {
 118       if (table[idx].code == code)
 119         {
 120           fprintf (config.map_file, "%s", table[idx].name);
 121           return;
 122         }
 123     }
 124   /* Not in table, just print it alone */
 125   fprintf (config.map_file, "%c", code);
 126 }
 127
 128 static void
 129 make_abs (ptr)
 130      etree_value_type *ptr;
 131 {
 132   asection *s = ptr->section->bfd_section;
 133   ptr->value += s->vma;
 134   ptr->section = abs_output_section;
 135 }
 136
 137 static etree_value_type
 138 new_abs (value)
 139      bfd_vma value;
 140 {
 141   etree_value_type new;
 142   new.valid_p = true;
 143   new.section = abs_output_section;
 144   new.value = value;
 145   return new;
 146 }
 147
 148 static void
 149 check (os, name, op)
 150      lang_output_section_statement_type *os;
 151      const char *name;
 152      const char *op;
 153 {
 154   if (os == NULL)
 155     einfo (_("%F%P: %s uses undefined section %s\n"), op, name);
 156   if (! os->processed)
 157     einfo (_("%F%P: %s forward reference of section %s\n"), op, name);
 158 }
 159
 160 etree_type *
 161 exp_intop (value)
 162      bfd_vma value;
 163 {
 164   etree_type *new = (etree_type *) stat_alloc (sizeof (new->value));
 165   new->type.node_code = INT;
 166   new->value.value = value;
 167   new->type.node_class = etree_value;
 168   return new;
 169
 170 }
 171
 172 /* Build an expression representing an unnamed relocateable value.  */
 173
 174 etree_type *
 175 exp_relop (section, value)
 176      asection *section;
 177      bfd_vma value;
 178 {
 179   etree_type *new = (etree_type *) stat_alloc (sizeof (new->rel));
 180   new->type.node_code = REL;
 181   new->type.node_class = etree_rel;
 182   new->rel.section = section;
 183   new->rel.value = value;
 184   return new;
 185 }
 186
 187 static etree_value_type
 188 new_rel (value, section)
 189      bfd_vma value;
 190      lang_output_section_statement_type *section;
 191 {
 192   etree_value_type new;
 193   new.valid_p = true;
 194   new.value = value;
 195   new.section = section;
 196   return new;
 197 }
 198
 199 static etree_value_type
 200 new_rel_from_section (value, section)
 201      bfd_vma value;
 202      lang_output_section_statement_type *section;
 203 {
 204   etree_value_type new;
 205   new.valid_p = true;
 206   new.value = value;
 207   new.section = section;
 208
 209   new.value -= section->bfd_section->vma;
 210
 211   return new;
 212 }
 213
 214 static etree_value_type
 215 fold_binary (tree, current_section, allocation_done, dot, dotp)
 216      etree_type *tree;
 217      lang_output_section_statement_type *current_section;
 218      lang_phase_type allocation_done;
 219      bfd_vma dot;
 220      bfd_vma *dotp;
 221 {
 222   etree_value_type result;
 223
 224   result = exp_fold_tree (tree->binary.lhs, current_section,
 225                           allocation_done, dot, dotp);
 226   if (result.valid_p)
 227     {
 228       etree_value_type other;
 229
 230       other = exp_fold_tree (tree->binary.rhs,
 231                              current_section,
 232                              allocation_done, dot, dotp);
 233       if (other.valid_p)
 234         {
 235           /* If the values are from different sections, or this is an
 236              absolute expression, make both the source arguments
 237              absolute.  However, adding or subtracting an absolute
 238              value from a relative value is meaningful, and is an
 239              exception.  */
 240           if (current_section != abs_output_section
 241               && (other.section == abs_output_section
 242                   || (result.section == abs_output_section
 243                       && tree->type.node_code == '+'))
 244               && (tree->type.node_code == '+'
 245                   || tree->type.node_code == '-'))
 246             {
 247               etree_value_type hold;
 248
 249               /* If there is only one absolute term, make sure it is the
 250                  second one.  */
 251               if (other.section != abs_output_section)
 252                 {
 253                   hold = result;
 254                   result = other;
 255                   other = hold;
 256                 }
 257             }
 258           else if (result.section != other.section
 259                    || current_section == abs_output_section)
 260             {
 261               make_abs (&result);
 262               make_abs (&other);
 263             }
 264
 265           switch (tree->type.node_code)
 266             {
 267             case '%':
 268               if (other.value == 0)
 269                 einfo (_("%F%S %% by zero\n"));
 270               result.value = ((bfd_signed_vma) result.value
 271                               % (bfd_signed_vma) other.value);
 272               break;
 273
 274             case '/':
 275               if (other.value == 0)
 276                 einfo (_("%F%S / by zero\n"));
 277               result.value = ((bfd_signed_vma) result.value
 278                               / (bfd_signed_vma) other.value);
 279               break;
 280
 281 #define BOP(x,y) case x : result.value = result.value y other.value; break;
 282               BOP ('+', +);
 283               BOP ('*', *);
 284               BOP ('-', -);
 285               BOP (LSHIFT, <<);
 286               BOP (RSHIFT, >>);
 287               BOP (EQ, ==);
 288               BOP (NE, !=);
 289               BOP ('<', <);
 290               BOP ('>', >);
 291               BOP (LE, <=);
 292               BOP (GE, >=);
 293               BOP ('&', &);
 294               BOP ('^', ^);
 295               BOP ('|', |);
 296               BOP (ANDAND, &&);
 297               BOP (OROR, ||);
 298
 299             case MAX_K:
 300               if (result.value < other.value)
 301                 result = other;
 302               break;
 303
 304             case MIN_K:
 305               if (result.value > other.value)
 306                 result = other;
 307               break;
 308
 309             default:
 310               FAIL ();
 311             }
 312         }
 313       else
 314         {
 315           result.valid_p = false;
 316         }
 317     }
 318
 319   return result;
 320 }
 321
 322 etree_value_type
 323 invalid ()
 324 {
 325   etree_value_type new;
 326   new.valid_p = false;
 327   return new;
 328 }
 329
 330 static etree_value_type
 331 fold_name (tree, current_section, allocation_done, dot)
 332      etree_type *tree;
 333      lang_output_section_statement_type *current_section;
 334      lang_phase_type allocation_done;
 335      bfd_vma dot;
 336 {
 337   etree_value_type result;
 338   switch (tree->type.node_code)
 339     {
 340     case SIZEOF_HEADERS:
 341       if (allocation_done != lang_first_phase_enum)
 342         {
 343           result = new_abs ((bfd_vma)
 344                             bfd_sizeof_headers (output_bfd,
 345                                                 link_info.relocateable));
 346         }
 347       else
 348         {
 349           result.valid_p = false;
 350         }
 351       break;
 352     case DEFINED:
 353       if (allocation_done == lang_first_phase_enum)
 354         result.valid_p = false;
 355       else
 356         {
 357           struct bfd_link_hash_entry *h;
 358
 359           h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
 360                                             tree->name.name,
 361                                             false, false, true);
 362           result.value = (h != (struct bfd_link_hash_entry *) NULL
 363                           && (h->type == bfd_link_hash_defined
 364                               || h->type == bfd_link_hash_defweak
 365                               || h->type == bfd_link_hash_common));
 366           result.section = 0;
 367           result.valid_p = true;
 368         }
 369       break;
 370     case NAME:
 371       result.valid_p = false;
 372       if (tree->name.name[0] == '.' && tree->name.name[1] == 0)
 373         {
 374           if (allocation_done != lang_first_phase_enum)
 375             result = new_rel_from_section (dot, current_section);
 376           else
 377             result = invalid ();
 378         }
 379       else if (allocation_done != lang_first_phase_enum)
 380         {
 381           struct bfd_link_hash_entry *h;
 382
 383           h = bfd_wrapped_link_hash_lookup (output_bfd, &link_info,
 384                                             tree->name.name,
 385                                             false, false, true);
 386           if (h != NULL
 387               && (h->type == bfd_link_hash_defined
 388                   || h->type == bfd_link_hash_defweak))
 389             {
 390               if (bfd_is_abs_section (h->u.def.section))
 391                 result = new_abs (h->u.def.value);
 392               else if (allocation_done == lang_final_phase_enum
 393                        || allocation_done == lang_allocating_phase_enum)
 394                 {
 395                   asection *output_section;
 396
 397                   output_section = h->u.def.section->output_section;
 398                   if (output_section == NULL)
 399                     einfo (_("%X%S: unresolvable symbol `%s' referenced in expression\n"),
 400                            tree->name.name);
 401                   else
 402                     {
 403                       lang_output_section_statement_type *os;
 404
 405                       os = (lang_output_section_statement_lookup
 406                             (bfd_get_section_name (output_bfd,
 407                                                    output_section)));
 408
 409                       /* FIXME: Is this correct if this section is
 410                          being linked with -R?  */
 411                       result = new_rel ((h->u.def.value
 412                                          + h->u.def.section->output_offset),
 413                                         os);
 414                     }
 415                 }
 416             }
 417           else if (allocation_done == lang_final_phase_enum)
 418             einfo (_("%F%S: undefined symbol `%s' referenced in expression\n"),
 419                    tree->name.name);
 420         }
 421       break;
 422
 423     case ADDR:
 424       if (allocation_done != lang_first_phase_enum)
 425         {
 426           lang_output_section_statement_type *os;
 427
 428           os = lang_output_section_find (tree->name.name);
 429           check (os, tree->name.name, "ADDR");
 430           result = new_rel (0, os);
 431         }
 432       else
 433         result = invalid ();
 434       break;
 435
 436     case LOADADDR:
 437       if (allocation_done != lang_first_phase_enum)
 438         {
 439           lang_output_section_statement_type *os;
 440
 441           os = lang_output_section_find (tree->name.name);
 442           check (os, tree->name.name, "LOADADDR");
 443           if (os->load_base == NULL)
 444             result = new_rel (0, os);
 445           else
 446             result = exp_fold_tree_no_dot (os->load_base,
 447                                            abs_output_section,
 448                                            allocation_done);
 449         }
 450       else
 451         result = invalid ();
 452       break;
 453
 454     case SIZEOF:
 455       if (allocation_done != lang_first_phase_enum)
 456         {
 457           int opb = bfd_octets_per_byte (output_bfd);
 458           lang_output_section_statement_type *os;
 459
 460           os = lang_output_section_find (tree->name.name);
 461           check (os, tree->name.name, "SIZEOF");
 462           result = new_abs (os->bfd_section->_raw_size / opb);
 463         }
 464       else
 465         result = invalid ();
 466       break;
 467
 468     default:
 469       FAIL ();
 470       break;
 471     }
 472
 473   return result;
 474 }
 475
 476 etree_value_type
 477 exp_fold_tree (tree, current_section, allocation_done, dot, dotp)
 478      etree_type *tree;
 479      lang_output_section_statement_type *current_section;
 480      lang_phase_type allocation_done;
 481      bfd_vma dot;
 482      bfd_vma *dotp;
 483 {
 484   etree_value_type result;
 485
 486   if (tree == NULL)
 487     {
 488       result.valid_p = false;
 489       return result;
 490     }
 491
 492   switch (tree->type.node_class)
 493     {
 494     case etree_value:
 495       result = new_rel (tree->value.value, current_section);
 496       break;
 497
 498     case etree_rel:
 499       if (allocation_done != lang_final_phase_enum)
 500         result.valid_p = false;
 501       else
 502         result = new_rel ((tree->rel.value
 503                            + tree->rel.section->output_section->vma
 504                            + tree->rel.section->output_offset),
 505                           current_section);
 506       break;
 507
 508     case etree_assert:
 509       result = exp_fold_tree (tree->assert_s.child,
 510                               current_section,
 511                               allocation_done, dot, dotp);
 512       if (result.valid_p)
 513         {
 514           if (! result.value)
 515             einfo ("%F%P: %s\n", tree->assert_s.message);
 516           return result;
 517         }
 518       break;
 519
 520     case etree_unary:
 521       result = exp_fold_tree (tree->unary.child,
 522                               current_section,
 523                               allocation_done, dot, dotp);
 524       if (result.valid_p)
 525         {
 526           switch (tree->type.node_code)
 527             {
 528             case ALIGN_K:
 529               if (allocation_done != lang_first_phase_enum)
 530                 result = new_rel_from_section (ALIGN_N (dot, result.value),
 531                                                current_section);
 532               else
 533                 result.valid_p = false;
 534               break;
 535
 536             case ABSOLUTE:
 537               if (allocation_done != lang_first_phase_enum && result.valid_p)
 538                 {
 539                   result.value += result.section->bfd_section->vma;
 540                   result.section = abs_output_section;
 541                 }
 542               else
 543                 result.valid_p = false;
 544               break;
 545
 546             case '~':
 547               make_abs (&result);
 548               result.value = ~result.value;
 549               break;
 550
 551             case '!':
 552               make_abs (&result);
 553               result.value = !result.value;
 554               break;
 555
 556             case '-':
 557               make_abs (&result);
 558               result.value = -result.value;
 559               break;
 560
 561             case NEXT:
 562               /* Return next place aligned to value.  */
 563               if (allocation_done == lang_allocating_phase_enum)
 564                 {
 565                   make_abs (&result);
 566                   result.value = ALIGN_N (dot, result.value);
 567                 }
 568               else
 569                 result.valid_p = false;
 570               break;
 571
 572             default:
 573               FAIL ();
 574               break;
 575             }
 576         }
 577       break;
 578
 579     case etree_trinary:
 580       result = exp_fold_tree (tree->trinary.cond, current_section,
 581                               allocation_done, dot, dotp);
 582       if (result.valid_p)
 583         result = exp_fold_tree ((result.value
 584                                  ? tree->trinary.lhs
 585                                  : tree->trinary.rhs),
 586                                 current_section,
 587                                 allocation_done, dot, dotp);
 588       break;
 589
 590     case etree_binary:
 591       result = fold_binary (tree, current_section, allocation_done,
 592                             dot, dotp);
 593       break;
 594
 595     case etree_assign:
 596     case etree_provide:
 597     case etree_provided:
 598       if (tree->assign.dst[0] == '.' && tree->assign.dst[1] == 0)
 599         {
 600           /* Assignment to dot can only be done during allocation */
 601           if (tree->type.node_class != etree_assign)
 602             einfo (_("%F%S can not PROVIDE assignment to location counter\n"));
 603           if (allocation_done == lang_allocating_phase_enum
 604               || (allocation_done == lang_final_phase_enum
 605                   && current_section == abs_output_section))
 606             {
 607               result = exp_fold_tree (tree->assign.src,
 608                                       current_section,
 609                                       lang_allocating_phase_enum, dot,
 610                                       dotp);
 611               if (! result.valid_p)
 612                 einfo (_("%F%S invalid assignment to location counter\n"));
 613               else
 614                 {
 615                   if (current_section == NULL)
 616                     einfo (_("%F%S assignment to location counter invalid outside of SECTION\n"));
 617                   else
 618                     {
 619                       bfd_vma nextdot;
 620
 621                       nextdot = (result.value
 622                                  + current_section->bfd_section->vma);
 623                       if (nextdot < dot
 624                           && current_section != abs_output_section)
 625                         {
 626                           einfo (_("%F%S cannot move location counter backwards (from %V to %V)\n"),
 627                                  dot, nextdot);
 628                         }
 629                       else
 630                         *dotp = nextdot;
 631                     }
 632                 }
 633             }
 634         }
 635       else
 636         {
 637           result = exp_fold_tree (tree->assign.src,
 638                                   current_section, allocation_done,
 639                                   dot, dotp);
 640           if (result.valid_p)
 641             {
 642               boolean create;
 643               struct bfd_link_hash_entry *h;
 644
 645               if (tree->type.node_class == etree_assign)
 646                 create = true;
 647               else
 648                 create = false;
 649               h = bfd_link_hash_lookup (link_info.hash, tree->assign.dst,
 650                                         create, false, false);
 651               if (h == (struct bfd_link_hash_entry *) NULL)
 652                 {
 653                   if (tree->type.node_class == etree_assign)
 654                     einfo (_("%P%F:%s: hash creation failed\n"),
 655                            tree->assign.dst);
 656                 }
 657               else if (tree->type.node_class == etree_provide
 658                        && h->type != bfd_link_hash_undefined
 659                        && h->type != bfd_link_hash_common)
 660                 {
 661                   /* Do nothing.  The symbol was defined by some
 662                      object.  */
 663                 }
 664               else
 665                 {
 666                   /* FIXME: Should we worry if the symbol is already
 667                      defined?  */
 668                   h->type = bfd_link_hash_defined;
 669                   h->u.def.value = result.value;
 670                   h->u.def.section = result.section->bfd_section;
 671                   if (tree->type.node_class == etree_provide)
 672                     tree->type.node_class = etree_provided;
 673                 }
 674             }
 675         }
 676       break;
 677
 678     case etree_name:
 679       result = fold_name (tree, current_section, allocation_done, dot);
 680       break;
 681
 682     default:
 683       FAIL ();
 684       break;
 685     }
 686
 687   return result;
 688 }
 689
 690 static etree_value_type
 691 exp_fold_tree_no_dot (tree, current_section, allocation_done)
 692      etree_type *tree;
 693      lang_output_section_statement_type *current_section;
 694      lang_phase_type allocation_done;
 695 {
 696   return exp_fold_tree (tree, current_section, allocation_done,
 697                         (bfd_vma) 0, (bfd_vma *) NULL);
 698 }
 699
 700 etree_type *
 701 exp_binop (code, lhs, rhs)
 702      int code;
 703      etree_type *lhs;
 704      etree_type *rhs;
 705 {
 706   etree_type value, *new;
 707   etree_value_type r;
 708
 709   value.type.node_code = code;
 710   value.binary.lhs = lhs;
 711   value.binary.rhs = rhs;
 712   value.type.node_class = etree_binary;
 713   r = exp_fold_tree_no_dot (&value,
 714                             abs_output_section,
 715                             lang_first_phase_enum);
 716   if (r.valid_p)
 717     {
 718       return exp_intop (r.value);
 719     }
 720   new = (etree_type *) stat_alloc (sizeof (new->binary));
 721   memcpy ((char *) new, (char *) &value, sizeof (new->binary));
 722   return new;
 723 }
 724
 725 etree_type *
 726 exp_trinop (code, cond, lhs, rhs)
 727      int code;
 728      etree_type *cond;
 729      etree_type *lhs;
 730      etree_type *rhs;
 731 {
 732   etree_type value, *new;
 733   etree_value_type r;
 734   value.type.node_code = code;
 735   value.trinary.lhs = lhs;
 736   value.trinary.cond = cond;
 737   value.trinary.rhs = rhs;
 738   value.type.node_class = etree_trinary;
 739   r = exp_fold_tree_no_dot (&value,
 740                             (lang_output_section_statement_type *) NULL,
 741                             lang_first_phase_enum);
 742   if (r.valid_p)
 743     {
 744       return exp_intop (r.value);
 745     }
 746   new = (etree_type *) stat_alloc (sizeof (new->trinary));
 747   memcpy ((char *) new, (char *) &value, sizeof (new->trinary));
 748   return new;
 749 }
 750
 751 etree_type *
 752 exp_unop (code, child)
 753      int code;
 754      etree_type *child;
 755 {
 756   etree_type value, *new;
 757
 758   etree_value_type r;
 759   value.unary.type.node_code = code;
 760   value.unary.child = child;
 761   value.unary.type.node_class = etree_unary;
 762   r = exp_fold_tree_no_dot (&value, abs_output_section,
 763                             lang_first_phase_enum);
 764   if (r.valid_p)
 765     {
 766       return exp_intop (r.value);
 767     }
 768   new = (etree_type *) stat_alloc (sizeof (new->unary));
 769   memcpy ((char *) new, (char *) &value, sizeof (new->unary));
 770   return new;
 771 }
 772
 773 etree_type *
 774 exp_nameop (code, name)
 775      int code;
 776      CONST char *name;
 777 {
 778   etree_type value, *new;
 779   etree_value_type r;
 780   value.name.type.node_code = code;
 781   value.name.name = name;
 782   value.name.type.node_class = etree_name;
 783
 784   r = exp_fold_tree_no_dot (&value,
 785                             (lang_output_section_statement_type *) NULL,
 786                             lang_first_phase_enum);
 787   if (r.valid_p)
 788     {
 789       return exp_intop (r.value);
 790     }
 791   new = (etree_type *) stat_alloc (sizeof (new->name));
 792   memcpy ((char *) new, (char *) &value, sizeof (new->name));
 793   return new;
 794
 795 }
 796
 797 etree_type *
 798 exp_assop (code, dst, src)
 799      int code;
 800      CONST char *dst;
 801      etree_type *src;
 802 {
 803   etree_type value, *new;
 804
 805   value.assign.type.node_code = code;
 806
 807   value.assign.src = src;
 808   value.assign.dst = dst;
 809   value.assign.type.node_class = etree_assign;
 810
 811 #if 0
 812   if (exp_fold_tree_no_dot (&value, &result))
 813     {
 814       return exp_intop (result);
 815     }
 816 #endif
 817   new = (etree_type *) stat_alloc (sizeof (new->assign));
 818   memcpy ((char *) new, (char *) &value, sizeof (new->assign));
 819   return new;
 820 }
 821
 822 /* Handle PROVIDE.  */
 823
 824 etree_type *
 825 exp_provide (dst, src)
 826      const char *dst;
 827      etree_type *src;
 828 {
 829   etree_type *n;
 830
 831   n = (etree_type *) stat_alloc (sizeof (n->assign));
 832   n->assign.type.node_code = '=';
 833   n->assign.type.node_class = etree_provide;
 834   n->assign.src = src;
 835   n->assign.dst = dst;
 836   return n;
 837 }
 838
 839 /* Handle ASSERT.  */
 840
 841 etree_type *
 842 exp_assert (exp, message)
 843      etree_type *exp;
 844      const char *message;
 845 {
 846   etree_type *n;
 847
 848   n = (etree_type *) stat_alloc (sizeof (n->assert_s));
 849   n->assert_s.type.node_code = '!';
 850   n->assert_s.type.node_class = etree_assert;
 851   n->assert_s.child = exp;
 852   n->assert_s.message = message;
 853   return n;
 854 }
 855
 856 void
 857 exp_print_tree (tree)
 858      etree_type *tree;
 859 {
 860   switch (tree->type.node_class)
 861     {
 862     case etree_value:
 863       minfo ("0x%v", tree->value.value);
 864       return;
 865     case etree_rel:
 866       if (tree->rel.section->owner != NULL)
 867         minfo ("%B:", tree->rel.section->owner);
 868       minfo ("%s+0x%v", tree->rel.section->name, tree->rel.value);
 869       return;
 870     case etree_assign:
 871 #if 0
 872       if (tree->assign.dst->sdefs != (asymbol *) NULL)
 873         {
 874           fprintf (config.map_file, "%s (%x) ", tree->assign.dst->name,
 875                    tree->assign.dst->sdefs->value);
 876         }
 877       else
 878         {
 879           fprintf (config.map_file, "%s (UNDEFINED)", tree->assign.dst->name);
 880         }
 881 #endif
 882       fprintf (config.map_file, "%s", tree->assign.dst);
 883       exp_print_token (tree->type.node_code);
 884       exp_print_tree (tree->assign.src);
 885       break;
 886     case etree_provide:
 887     case etree_provided:
 888       fprintf (config.map_file, "PROVIDE (%s, ", tree->assign.dst);
 889       exp_print_tree (tree->assign.src);
 890       fprintf (config.map_file, ")");
 891       break;
 892     case etree_binary:
 893       fprintf (config.map_file, "(");
 894       exp_print_tree (tree->binary.lhs);
 895       exp_print_token (tree->type.node_code);
 896       exp_print_tree (tree->binary.rhs);
 897       fprintf (config.map_file, ")");
 898       break;
 899     case etree_trinary:
 900       exp_print_tree (tree->trinary.cond);
 901       fprintf (config.map_file, "?");
 902       exp_print_tree (tree->trinary.lhs);
 903       fprintf (config.map_file, ":");
 904       exp_print_tree (tree->trinary.rhs);
 905       break;
 906     case etree_unary:
 907       exp_print_token (tree->unary.type.node_code);
 908       if (tree->unary.child)
 909         {
 910           fprintf (config.map_file, "(");
 911           exp_print_tree (tree->unary.child);
 912           fprintf (config.map_file, ")");
 913         }
 914       break;
 915
 916     case etree_assert:
 917       fprintf (config.map_file, "ASSERT (");
 918       exp_print_tree (tree->assert_s.child);
 919       fprintf (config.map_file, ", %s)", tree->assert_s.message);
 920       break;
 921
 922     case etree_undef:
 923       fprintf (config.map_file, "????????");
 924       break;
 925     case etree_name:
 926       if (tree->type.node_code == NAME)
 927         {
 928           fprintf (config.map_file, "%s", tree->name.name);
 929         }
 930       else
 931         {
 932           exp_print_token (tree->type.node_code);
 933           if (tree->name.name)
 934             fprintf (config.map_file, "(%s)", tree->name.name);
 935         }
 936       break;
 937     default:
 938       FAIL ();
 939       break;
 940     }
 941 }
 942
 943 bfd_vma
 944 exp_get_vma (tree, def, name, allocation_done)
 945      etree_type *tree;
 946      bfd_vma def;
 947      char *name;
 948      lang_phase_type allocation_done;
 949 {
 950   etree_value_type r;
 951
 952   if (tree != NULL)
 953     {
 954       r = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
 955       if (! r.valid_p && name != NULL)
 956         einfo (_("%F%S nonconstant expression for %s\n"), name);
 957       return r.value;
 958     }
 959   else
 960     return def;
 961 }
 962
 963 int
 964 exp_get_value_int (tree, def, name, allocation_done)
 965      etree_type *tree;
 966      int def;
 967      char *name;
 968      lang_phase_type allocation_done;
 969 {
 970   return (int) exp_get_vma (tree, (bfd_vma) def, name, allocation_done);
 971 }
 972
 973 bfd_vma
 974 exp_get_abs_int (tree, def, name, allocation_done)
 975      etree_type *tree;
 976      int def ATTRIBUTE_UNUSED;
 977      char *name;
 978      lang_phase_type allocation_done;
 979 {
 980   etree_value_type res;
 981   res = exp_fold_tree_no_dot (tree, abs_output_section, allocation_done);
 982
 983   if (res.valid_p)
 984     {
 985       res.value += res.section->bfd_section->vma;
 986     }
 987   else
 988     {
 989       einfo (_("%F%S non constant expression for %s\n"), name);
 990     }
 991   return res.value;
 992 }