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