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