1 /* C preprocessor macro tables for GDB. 2 Copyright (C) 2002, 2007, 2008, 2009 Free Software Foundation, Inc. 3 Contributed by Red Hat, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "gdb_obstack.h" 22 #include "splay-tree.h" 23 #include "symtab.h" 24 #include "symfile.h" 25 #include "objfiles.h" 26 #include "macrotab.h" 27 #include "gdb_assert.h" 28 #include "bcache.h" 29 #include "complaints.h" 30 31 32 /* The macro table structure. */ 33 34 struct macro_table 35 { 36 /* The obstack this table's data should be allocated in, or zero if 37 we should use xmalloc. */ 38 struct obstack *obstack; 39 40 /* The bcache we should use to hold macro names, argument names, and 41 definitions, or zero if we should use xmalloc. */ 42 struct bcache *bcache; 43 44 /* The main source file for this compilation unit --- the one whose 45 name was given to the compiler. This is the root of the 46 #inclusion tree; everything else is #included from here. */ 47 struct macro_source_file *main_source; 48 49 /* True if macros in this table can be redefined without issuing an 50 error. */ 51 int redef_ok; 52 53 /* The table of macro definitions. This is a splay tree (an ordered 54 binary tree that stays balanced, effectively), sorted by macro 55 name. Where a macro gets defined more than once (presumably with 56 an #undefinition in between), we sort the definitions by the 57 order they would appear in the preprocessor's output. That is, 58 if `a.c' #includes `m.h' and then #includes `n.h', and both 59 header files #define X (with an #undef somewhere in between), 60 then the definition from `m.h' appears in our splay tree before 61 the one from `n.h'. 62 63 The splay tree's keys are `struct macro_key' pointers; 64 the values are `struct macro_definition' pointers. 65 66 The splay tree, its nodes, and the keys and values are allocated 67 in obstack, if it's non-zero, or with xmalloc otherwise. The 68 macro names, argument names, argument name arrays, and definition 69 strings are all allocated in bcache, if non-zero, or with xmalloc 70 otherwise. */ 71 splay_tree definitions; 72 }; 73 74 75 76 /* Allocation and freeing functions. */ 77 78 /* Allocate SIZE bytes of memory appropriately for the macro table T. 79 This just checks whether T has an obstack, or whether its pieces 80 should be allocated with xmalloc. */ 81 static void * 82 macro_alloc (int size, struct macro_table *t) 83 { 84 if (t->obstack) 85 return obstack_alloc (t->obstack, size); 86 else 87 return xmalloc (size); 88 } 89 90 91 static void 92 macro_free (void *object, struct macro_table *t) 93 { 94 if (t->obstack) 95 /* There are cases where we need to remove entries from a macro 96 table, even when reading debugging information. This should be 97 rare, and there's no easy way to free arbitrary data from an 98 obstack, so we just leak it. */ 99 ; 100 else 101 xfree (object); 102 } 103 104 105 /* If the macro table T has a bcache, then cache the LEN bytes at ADDR 106 there, and return the cached copy. Otherwise, just xmalloc a copy 107 of the bytes, and return a pointer to that. */ 108 static const void * 109 macro_bcache (struct macro_table *t, const void *addr, int len) 110 { 111 if (t->bcache) 112 return bcache (addr, len, t->bcache); 113 else 114 { 115 void *copy = xmalloc (len); 116 memcpy (copy, addr, len); 117 return copy; 118 } 119 } 120 121 122 /* If the macro table T has a bcache, cache the null-terminated string 123 S there, and return a pointer to the cached copy. Otherwise, 124 xmalloc a copy and return that. */ 125 static const char * 126 macro_bcache_str (struct macro_table *t, const char *s) 127 { 128 return (char *) macro_bcache (t, s, strlen (s) + 1); 129 } 130 131 132 /* Free a possibly bcached object OBJ. That is, if the macro table T 133 has a bcache, do nothing; otherwise, xfree OBJ. */ 134 static void 135 macro_bcache_free (struct macro_table *t, void *obj) 136 { 137 if (t->bcache) 138 /* There are cases where we need to remove entries from a macro 139 table, even when reading debugging information. This should be 140 rare, and there's no easy way to free data from a bcache, so we 141 just leak it. */ 142 ; 143 else 144 xfree (obj); 145 } 146 147 148 149 /* Macro tree keys, w/their comparison, allocation, and freeing functions. */ 150 151 /* A key in the splay tree. */ 152 struct macro_key 153 { 154 /* The table we're in. We only need this in order to free it, since 155 the splay tree library's key and value freeing functions require 156 that the key or value contain all the information needed to free 157 themselves. */ 158 struct macro_table *table; 159 160 /* The name of the macro. This is in the table's bcache, if it has 161 one. */ 162 const char *name; 163 164 /* The source file and line number where the definition's scope 165 begins. This is also the line of the definition itself. */ 166 struct macro_source_file *start_file; 167 int start_line; 168 169 /* The first source file and line after the definition's scope. 170 (That is, the scope does not include this endpoint.) If end_file 171 is zero, then the definition extends to the end of the 172 compilation unit. */ 173 struct macro_source_file *end_file; 174 int end_line; 175 }; 176 177 178 /* Return the #inclusion depth of the source file FILE. This is the 179 number of #inclusions it took to reach this file. For the main 180 source file, the #inclusion depth is zero; for a file it #includes 181 directly, the depth would be one; and so on. */ 182 static int 183 inclusion_depth (struct macro_source_file *file) 184 { 185 int depth; 186 187 for (depth = 0; file->included_by; depth++) 188 file = file->included_by; 189 190 return depth; 191 } 192 193 194 /* Compare two source locations (from the same compilation unit). 195 This is part of the comparison function for the tree of 196 definitions. 197 198 LINE1 and LINE2 are line numbers in the source files FILE1 and 199 FILE2. Return a value: 200 - less than zero if {LINE,FILE}1 comes before {LINE,FILE}2, 201 - greater than zero if {LINE,FILE}1 comes after {LINE,FILE}2, or 202 - zero if they are equal. 203 204 When the two locations are in different source files --- perhaps 205 one is in a header, while another is in the main source file --- we 206 order them by where they would appear in the fully pre-processed 207 sources, where all the #included files have been substituted into 208 their places. */ 209 static int 210 compare_locations (struct macro_source_file *file1, int line1, 211 struct macro_source_file *file2, int line2) 212 { 213 /* We want to treat positions in an #included file as coming *after* 214 the line containing the #include, but *before* the line after the 215 include. As we walk up the #inclusion tree toward the main 216 source file, we update fileX and lineX as we go; includedX 217 indicates whether the original position was from the #included 218 file. */ 219 int included1 = 0; 220 int included2 = 0; 221 222 /* If a file is zero, that means "end of compilation unit." Handle 223 that specially. */ 224 if (! file1) 225 { 226 if (! file2) 227 return 0; 228 else 229 return 1; 230 } 231 else if (! file2) 232 return -1; 233 234 /* If the two files are not the same, find their common ancestor in 235 the #inclusion tree. */ 236 if (file1 != file2) 237 { 238 /* If one file is deeper than the other, walk up the #inclusion 239 chain until the two files are at least at the same *depth*. 240 Then, walk up both files in synchrony until they're the same 241 file. That file is the common ancestor. */ 242 int depth1 = inclusion_depth (file1); 243 int depth2 = inclusion_depth (file2); 244 245 /* Only one of these while loops will ever execute in any given 246 case. */ 247 while (depth1 > depth2) 248 { 249 line1 = file1->included_at_line; 250 file1 = file1->included_by; 251 included1 = 1; 252 depth1--; 253 } 254 while (depth2 > depth1) 255 { 256 line2 = file2->included_at_line; 257 file2 = file2->included_by; 258 included2 = 1; 259 depth2--; 260 } 261 262 /* Now both file1 and file2 are at the same depth. Walk toward 263 the root of the tree until we find where the branches meet. */ 264 while (file1 != file2) 265 { 266 line1 = file1->included_at_line; 267 file1 = file1->included_by; 268 /* At this point, we know that the case the includedX flags 269 are trying to deal with won't come up, but we'll just 270 maintain them anyway. */ 271 included1 = 1; 272 273 line2 = file2->included_at_line; 274 file2 = file2->included_by; 275 included2 = 1; 276 277 /* Sanity check. If file1 and file2 are really from the 278 same compilation unit, then they should both be part of 279 the same tree, and this shouldn't happen. */ 280 gdb_assert (file1 && file2); 281 } 282 } 283 284 /* Now we've got two line numbers in the same file. */ 285 if (line1 == line2) 286 { 287 /* They can't both be from #included files. Then we shouldn't 288 have walked up this far. */ 289 gdb_assert (! included1 || ! included2); 290 291 /* Any #included position comes after a non-#included position 292 with the same line number in the #including file. */ 293 if (included1) 294 return 1; 295 else if (included2) 296 return -1; 297 else 298 return 0; 299 } 300 else 301 return line1 - line2; 302 } 303 304 305 /* Compare a macro key KEY against NAME, the source file FILE, and 306 line number LINE. 307 308 Sort definitions by name; for two definitions with the same name, 309 place the one whose definition comes earlier before the one whose 310 definition comes later. 311 312 Return -1, 0, or 1 if key comes before, is identical to, or comes 313 after NAME, FILE, and LINE. */ 314 static int 315 key_compare (struct macro_key *key, 316 const char *name, struct macro_source_file *file, int line) 317 { 318 int names = strcmp (key->name, name); 319 if (names) 320 return names; 321 322 return compare_locations (key->start_file, key->start_line, 323 file, line); 324 } 325 326 327 /* The macro tree comparison function, typed for the splay tree 328 library's happiness. */ 329 static int 330 macro_tree_compare (splay_tree_key untyped_key1, 331 splay_tree_key untyped_key2) 332 { 333 struct macro_key *key1 = (struct macro_key *) untyped_key1; 334 struct macro_key *key2 = (struct macro_key *) untyped_key2; 335 336 return key_compare (key1, key2->name, key2->start_file, key2->start_line); 337 } 338 339 340 /* Construct a new macro key node for a macro in table T whose name is 341 NAME, and whose scope starts at LINE in FILE; register the name in 342 the bcache. */ 343 static struct macro_key * 344 new_macro_key (struct macro_table *t, 345 const char *name, 346 struct macro_source_file *file, 347 int line) 348 { 349 struct macro_key *k = macro_alloc (sizeof (*k), t); 350 351 memset (k, 0, sizeof (*k)); 352 k->table = t; 353 k->name = macro_bcache_str (t, name); 354 k->start_file = file; 355 k->start_line = line; 356 k->end_file = 0; 357 358 return k; 359 } 360 361 362 static void 363 macro_tree_delete_key (void *untyped_key) 364 { 365 struct macro_key *key = (struct macro_key *) untyped_key; 366 367 macro_bcache_free (key->table, (char *) key->name); 368 macro_free (key, key->table); 369 } 370 371 372 373 /* Building and querying the tree of #included files. */ 374 375 376 /* Allocate and initialize a new source file structure. */ 377 static struct macro_source_file * 378 new_source_file (struct macro_table *t, 379 const char *filename) 380 { 381 /* Get space for the source file structure itself. */ 382 struct macro_source_file *f = macro_alloc (sizeof (*f), t); 383 384 memset (f, 0, sizeof (*f)); 385 f->table = t; 386 f->filename = macro_bcache_str (t, filename); 387 f->includes = 0; 388 389 return f; 390 } 391 392 393 /* Free a source file, and all the source files it #included. */ 394 static void 395 free_macro_source_file (struct macro_source_file *src) 396 { 397 struct macro_source_file *child, *next_child; 398 399 /* Free this file's children. */ 400 for (child = src->includes; child; child = next_child) 401 { 402 next_child = child->next_included; 403 free_macro_source_file (child); 404 } 405 406 macro_bcache_free (src->table, (char *) src->filename); 407 macro_free (src, src->table); 408 } 409 410 411 struct macro_source_file * 412 macro_set_main (struct macro_table *t, 413 const char *filename) 414 { 415 /* You can't change a table's main source file. What would that do 416 to the tree? */ 417 gdb_assert (! t->main_source); 418 419 t->main_source = new_source_file (t, filename); 420 421 return t->main_source; 422 } 423 424 425 struct macro_source_file * 426 macro_main (struct macro_table *t) 427 { 428 gdb_assert (t->main_source); 429 430 return t->main_source; 431 } 432 433 434 void 435 macro_allow_redefinitions (struct macro_table *t) 436 { 437 gdb_assert (! t->obstack); 438 t->redef_ok = 1; 439 } 440 441 442 struct macro_source_file * 443 macro_include (struct macro_source_file *source, 444 int line, 445 const char *included) 446 { 447 struct macro_source_file *new; 448 struct macro_source_file **link; 449 450 /* Find the right position in SOURCE's `includes' list for the new 451 file. Skip inclusions at earlier lines, until we find one at the 452 same line or later --- or until the end of the list. */ 453 for (link = &source->includes; 454 *link && (*link)->included_at_line < line; 455 link = &(*link)->next_included) 456 ; 457 458 /* Did we find another file already #included at the same line as 459 the new one? */ 460 if (*link && line == (*link)->included_at_line) 461 { 462 /* This means the compiler is emitting bogus debug info. (GCC 463 circa March 2002 did this.) It also means that the splay 464 tree ordering function, macro_tree_compare, will abort, 465 because it can't tell which #inclusion came first. But GDB 466 should tolerate bad debug info. So: 467 468 First, squawk. */ 469 complaint (&symfile_complaints, 470 _("both `%s' and `%s' allegedly #included at %s:%d"), included, 471 (*link)->filename, source->filename, line); 472 473 /* Now, choose a new, unoccupied line number for this 474 #inclusion, after the alleged #inclusion line. */ 475 while (*link && line == (*link)->included_at_line) 476 { 477 /* This line number is taken, so try the next line. */ 478 line++; 479 link = &(*link)->next_included; 480 } 481 } 482 483 /* At this point, we know that LINE is an unused line number, and 484 *LINK points to the entry an #inclusion at that line should 485 precede. */ 486 new = new_source_file (source->table, included); 487 new->included_by = source; 488 new->included_at_line = line; 489 new->next_included = *link; 490 *link = new; 491 492 return new; 493 } 494 495 496 struct macro_source_file * 497 macro_lookup_inclusion (struct macro_source_file *source, const char *name) 498 { 499 /* Is SOURCE itself named NAME? */ 500 if (strcmp (name, source->filename) == 0) 501 return source; 502 503 /* The filename in the source structure is probably a full path, but 504 NAME could be just the final component of the name. */ 505 { 506 int name_len = strlen (name); 507 int src_name_len = strlen (source->filename); 508 509 /* We do mean < here, and not <=; if the lengths are the same, 510 then the strcmp above should have triggered, and we need to 511 check for a slash here. */ 512 if (name_len < src_name_len 513 && source->filename[src_name_len - name_len - 1] == '/' 514 && strcmp (name, source->filename + src_name_len - name_len) == 0) 515 return source; 516 } 517 518 /* It's not us. Try all our children, and return the lowest. */ 519 { 520 struct macro_source_file *child; 521 struct macro_source_file *best = NULL; 522 int best_depth = 0; 523 524 for (child = source->includes; child; child = child->next_included) 525 { 526 struct macro_source_file *result 527 = macro_lookup_inclusion (child, name); 528 529 if (result) 530 { 531 int result_depth = inclusion_depth (result); 532 533 if (! best || result_depth < best_depth) 534 { 535 best = result; 536 best_depth = result_depth; 537 } 538 } 539 } 540 541 return best; 542 } 543 } 544 545 546 547 /* Registering and looking up macro definitions. */ 548 549 550 /* Construct a definition for a macro in table T. Cache all strings, 551 and the macro_definition structure itself, in T's bcache. */ 552 static struct macro_definition * 553 new_macro_definition (struct macro_table *t, 554 enum macro_kind kind, 555 int argc, const char **argv, 556 const char *replacement) 557 { 558 struct macro_definition *d = macro_alloc (sizeof (*d), t); 559 560 memset (d, 0, sizeof (*d)); 561 d->table = t; 562 d->kind = kind; 563 d->replacement = macro_bcache_str (t, replacement); 564 565 if (kind == macro_function_like) 566 { 567 int i; 568 const char **cached_argv; 569 int cached_argv_size = argc * sizeof (*cached_argv); 570 571 /* Bcache all the arguments. */ 572 cached_argv = alloca (cached_argv_size); 573 for (i = 0; i < argc; i++) 574 cached_argv[i] = macro_bcache_str (t, argv[i]); 575 576 /* Now bcache the array of argument pointers itself. */ 577 d->argv = macro_bcache (t, cached_argv, cached_argv_size); 578 d->argc = argc; 579 } 580 581 /* We don't bcache the entire definition structure because it's got 582 a pointer to the macro table in it; since each compilation unit 583 has its own macro table, you'd only get bcache hits for identical 584 definitions within a compilation unit, which seems unlikely. 585 586 "So, why do macro definitions have pointers to their macro tables 587 at all?" Well, when the splay tree library wants to free a 588 node's value, it calls the value freeing function with nothing 589 but the value itself. It makes the (apparently reasonable) 590 assumption that the value carries enough information to free 591 itself. But not all macro tables have bcaches, so not all macro 592 definitions would be bcached. There's no way to tell whether a 593 given definition is bcached without knowing which table the 594 definition belongs to. ... blah. The thing's only sixteen 595 bytes anyway, and we can still bcache the name, args, and 596 definition, so we just don't bother bcaching the definition 597 structure itself. */ 598 return d; 599 } 600 601 602 /* Free a macro definition. */ 603 static void 604 macro_tree_delete_value (void *untyped_definition) 605 { 606 struct macro_definition *d = (struct macro_definition *) untyped_definition; 607 struct macro_table *t = d->table; 608 609 if (d->kind == macro_function_like) 610 { 611 int i; 612 613 for (i = 0; i < d->argc; i++) 614 macro_bcache_free (t, (char *) d->argv[i]); 615 macro_bcache_free (t, (char **) d->argv); 616 } 617 618 macro_bcache_free (t, (char *) d->replacement); 619 macro_free (d, t); 620 } 621 622 623 /* Find the splay tree node for the definition of NAME at LINE in 624 SOURCE, or zero if there is none. */ 625 static splay_tree_node 626 find_definition (const char *name, 627 struct macro_source_file *file, 628 int line) 629 { 630 struct macro_table *t = file->table; 631 splay_tree_node n; 632 633 /* Construct a macro_key object, just for the query. */ 634 struct macro_key query; 635 636 query.name = name; 637 query.start_file = file; 638 query.start_line = line; 639 query.end_file = NULL; 640 641 n = splay_tree_lookup (t->definitions, (splay_tree_key) &query); 642 if (! n) 643 { 644 /* It's okay for us to do two queries like this: the real work 645 of the searching is done when we splay, and splaying the tree 646 a second time at the same key is a constant time operation. 647 If this still bugs you, you could always just extend the 648 splay tree library with a predecessor-or-equal operation, and 649 use that. */ 650 splay_tree_node pred = splay_tree_predecessor (t->definitions, 651 (splay_tree_key) &query); 652 653 if (pred) 654 { 655 /* Make sure this predecessor actually has the right name. 656 We just want to search within a given name's definitions. */ 657 struct macro_key *found = (struct macro_key *) pred->key; 658 659 if (strcmp (found->name, name) == 0) 660 n = pred; 661 } 662 } 663 664 if (n) 665 { 666 struct macro_key *found = (struct macro_key *) n->key; 667 668 /* Okay, so this definition has the right name, and its scope 669 begins before the given source location. But does its scope 670 end after the given source location? */ 671 if (compare_locations (file, line, found->end_file, found->end_line) < 0) 672 return n; 673 else 674 return 0; 675 } 676 else 677 return 0; 678 } 679 680 681 /* If NAME already has a definition in scope at LINE in SOURCE, return 682 the key. If the old definition is different from the definition 683 given by KIND, ARGC, ARGV, and REPLACEMENT, complain, too. 684 Otherwise, return zero. (ARGC and ARGV are meaningless unless KIND 685 is `macro_function_like'.) */ 686 static struct macro_key * 687 check_for_redefinition (struct macro_source_file *source, int line, 688 const char *name, enum macro_kind kind, 689 int argc, const char **argv, 690 const char *replacement) 691 { 692 splay_tree_node n = find_definition (name, source, line); 693 694 if (n) 695 { 696 struct macro_key *found_key = (struct macro_key *) n->key; 697 struct macro_definition *found_def 698 = (struct macro_definition *) n->value; 699 int same = 1; 700 701 /* Is this definition the same as the existing one? 702 According to the standard, this comparison needs to be done 703 on lists of tokens, not byte-by-byte, as we do here. But 704 that's too hard for us at the moment, and comparing 705 byte-by-byte will only yield false negatives (i.e., extra 706 warning messages), not false positives (i.e., unnoticed 707 definition changes). */ 708 if (kind != found_def->kind) 709 same = 0; 710 else if (strcmp (replacement, found_def->replacement)) 711 same = 0; 712 else if (kind == macro_function_like) 713 { 714 if (argc != found_def->argc) 715 same = 0; 716 else 717 { 718 int i; 719 720 for (i = 0; i < argc; i++) 721 if (strcmp (argv[i], found_def->argv[i])) 722 same = 0; 723 } 724 } 725 726 if (! same) 727 { 728 complaint (&symfile_complaints, 729 _("macro `%s' redefined at %s:%d; original definition at %s:%d"), 730 name, source->filename, line, 731 found_key->start_file->filename, found_key->start_line); 732 } 733 734 return found_key; 735 } 736 else 737 return 0; 738 } 739 740 741 void 742 macro_define_object (struct macro_source_file *source, int line, 743 const char *name, const char *replacement) 744 { 745 struct macro_table *t = source->table; 746 struct macro_key *k = NULL; 747 struct macro_definition *d; 748 749 if (! t->redef_ok) 750 k = check_for_redefinition (source, line, 751 name, macro_object_like, 752 0, 0, 753 replacement); 754 755 /* If we're redefining a symbol, and the existing key would be 756 identical to our new key, then the splay_tree_insert function 757 will try to delete the old definition. When the definition is 758 living on an obstack, this isn't a happy thing. 759 760 Since this only happens in the presence of questionable debug 761 info, we just ignore all definitions after the first. The only 762 case I know of where this arises is in GCC's output for 763 predefined macros, and all the definitions are the same in that 764 case. */ 765 if (k && ! key_compare (k, name, source, line)) 766 return; 767 768 k = new_macro_key (t, name, source, line); 769 d = new_macro_definition (t, macro_object_like, 0, 0, replacement); 770 splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d); 771 } 772 773 774 void 775 macro_define_function (struct macro_source_file *source, int line, 776 const char *name, int argc, const char **argv, 777 const char *replacement) 778 { 779 struct macro_table *t = source->table; 780 struct macro_key *k = NULL; 781 struct macro_definition *d; 782 783 if (! t->redef_ok) 784 k = check_for_redefinition (source, line, 785 name, macro_function_like, 786 argc, argv, 787 replacement); 788 789 /* See comments about duplicate keys in macro_define_object. */ 790 if (k && ! key_compare (k, name, source, line)) 791 return; 792 793 /* We should also check here that all the argument names in ARGV are 794 distinct. */ 795 796 k = new_macro_key (t, name, source, line); 797 d = new_macro_definition (t, macro_function_like, argc, argv, replacement); 798 splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d); 799 } 800 801 802 void 803 macro_undef (struct macro_source_file *source, int line, 804 const char *name) 805 { 806 splay_tree_node n = find_definition (name, source, line); 807 808 if (n) 809 { 810 struct macro_key *key = (struct macro_key *) n->key; 811 812 /* If we're removing a definition at exactly the same point that 813 we defined it, then just delete the entry altogether. GCC 814 4.1.2 will generate DWARF that says to do this if you pass it 815 arguments like '-DFOO -UFOO -DFOO=2'. */ 816 if (source == key->start_file 817 && line == key->start_line) 818 splay_tree_remove (source->table->definitions, n->key); 819 820 else 821 { 822 /* This function is the only place a macro's end-of-scope 823 location gets set to anything other than "end of the 824 compilation unit" (i.e., end_file is zero). So if this 825 macro already has its end-of-scope set, then we're 826 probably seeing a second #undefinition for the same 827 #definition. */ 828 if (key->end_file) 829 { 830 complaint (&symfile_complaints, 831 _("macro '%s' is #undefined twice," 832 " at %s:%d and %s:%d"), 833 name, 834 source->filename, line, 835 key->end_file->filename, key->end_line); 836 } 837 838 /* Whether or not we've seen a prior #undefinition, wipe out 839 the old ending point, and make this the ending point. */ 840 key->end_file = source; 841 key->end_line = line; 842 } 843 } 844 else 845 { 846 /* According to the ISO C standard, an #undef for a symbol that 847 has no macro definition in scope is ignored. So we should 848 ignore it too. */ 849 #if 0 850 complaint (&symfile_complaints, 851 _("no definition for macro `%s' in scope to #undef at %s:%d"), 852 name, source->filename, line); 853 #endif 854 } 855 } 856 857 858 struct macro_definition * 859 macro_lookup_definition (struct macro_source_file *source, 860 int line, const char *name) 861 { 862 splay_tree_node n = find_definition (name, source, line); 863 864 if (n) 865 return (struct macro_definition *) n->value; 866 else 867 return 0; 868 } 869 870 871 struct macro_source_file * 872 macro_definition_location (struct macro_source_file *source, 873 int line, 874 const char *name, 875 int *definition_line) 876 { 877 splay_tree_node n = find_definition (name, source, line); 878 879 if (n) 880 { 881 struct macro_key *key = (struct macro_key *) n->key; 882 *definition_line = key->start_line; 883 return key->start_file; 884 } 885 else 886 return 0; 887 } 888 889 890 /* The type for callback data for iterating the splay tree in 891 macro_for_each and macro_for_each_in_scope. Only the latter uses 892 the FILE and LINE fields. */ 893 struct macro_for_each_data 894 { 895 macro_callback_fn fn; 896 void *user_data; 897 struct macro_source_file *file; 898 int line; 899 }; 900 901 /* Helper function for macro_for_each. */ 902 static int 903 foreach_macro (splay_tree_node node, void *arg) 904 { 905 struct macro_for_each_data *datum = (struct macro_for_each_data *) arg; 906 struct macro_key *key = (struct macro_key *) node->key; 907 struct macro_definition *def = (struct macro_definition *) node->value; 908 (*datum->fn) (key->name, def, datum->user_data); 909 return 0; 910 } 911 912 /* Call FN for every macro in TABLE. */ 913 void 914 macro_for_each (struct macro_table *table, macro_callback_fn fn, 915 void *user_data) 916 { 917 struct macro_for_each_data datum; 918 datum.fn = fn; 919 datum.user_data = user_data; 920 datum.file = NULL; 921 datum.line = 0; 922 splay_tree_foreach (table->definitions, foreach_macro, &datum); 923 } 924 925 static int 926 foreach_macro_in_scope (splay_tree_node node, void *info) 927 { 928 struct macro_for_each_data *datum = (struct macro_for_each_data *) info; 929 struct macro_key *key = (struct macro_key *) node->key; 930 struct macro_definition *def = (struct macro_definition *) node->value; 931 932 /* See if this macro is defined before the passed-in line, and 933 extends past that line. */ 934 if (compare_locations (key->start_file, key->start_line, 935 datum->file, datum->line) < 0 936 && (!key->end_file 937 || compare_locations (key->end_file, key->end_line, 938 datum->file, datum->line) >= 0)) 939 (*datum->fn) (key->name, def, datum->user_data); 940 return 0; 941 } 942 943 /* Call FN for every macro is visible in SCOPE. */ 944 void 945 macro_for_each_in_scope (struct macro_source_file *file, int line, 946 macro_callback_fn fn, void *user_data) 947 { 948 struct macro_for_each_data datum; 949 datum.fn = fn; 950 datum.user_data = user_data; 951 datum.file = file; 952 datum.line = line; 953 splay_tree_foreach (file->table->definitions, 954 foreach_macro_in_scope, &datum); 955 } 956 957 958 959 /* Creating and freeing macro tables. */ 960 961 962 struct macro_table * 963 new_macro_table (struct obstack *obstack, 964 struct bcache *b) 965 { 966 struct macro_table *t; 967 968 /* First, get storage for the `struct macro_table' itself. */ 969 if (obstack) 970 t = obstack_alloc (obstack, sizeof (*t)); 971 else 972 t = xmalloc (sizeof (*t)); 973 974 memset (t, 0, sizeof (*t)); 975 t->obstack = obstack; 976 t->bcache = b; 977 t->main_source = NULL; 978 t->redef_ok = 0; 979 t->definitions = (splay_tree_new_with_allocator 980 (macro_tree_compare, 981 ((splay_tree_delete_key_fn) macro_tree_delete_key), 982 ((splay_tree_delete_value_fn) macro_tree_delete_value), 983 ((splay_tree_allocate_fn) macro_alloc), 984 ((splay_tree_deallocate_fn) macro_free), 985 t)); 986 987 return t; 988 } 989 990 991 void 992 free_macro_table (struct macro_table *table) 993 { 994 /* Free the source file tree. */ 995 free_macro_source_file (table->main_source); 996 997 /* Free the table of macro definitions. */ 998 splay_tree_delete (table->definitions); 999 } 1000