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