1 /* C preprocessor macro tables for GDB.
2 Copyright (C) 2002-2015 Free Software Foundation, Inc.
3 Contributed by Red Hat, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "gdb_obstack.h"
22 #include "splay-tree.h"
23 #include "filenames.h"
29 #include "complaints.h"
33 /* The macro table structure. */
37 /* The obstack this table's data should be allocated in, or zero if
38 we should use xmalloc. */
39 struct obstack *obstack;
41 /* The bcache we should use to hold macro names, argument names, and
42 definitions, or zero if we should use xmalloc. */
43 struct bcache *bcache;
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;
50 /* Backlink to containing compilation unit, or NULL if there isn't one. */
51 struct compunit_symtab *compunit_symtab;
53 /* True if macros in this table can be redefined without issuing an
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
67 The splay tree's keys are `struct macro_key' pointers;
68 the values are `struct macro_definition' pointers.
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
75 splay_tree definitions;
80 /* Allocation and freeing functions. */
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. */
86 macro_alloc (int size, struct macro_table *t)
89 return obstack_alloc (t->obstack, size);
91 return xmalloc (size);
96 macro_free (void *object, struct macro_table *t)
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. */
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. */
113 macro_bcache (struct macro_table *t, const void *addr, int len)
116 return bcache (addr, len, t->bcache);
119 void *copy = xmalloc (len);
121 memcpy (copy, addr, len);
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. */
131 macro_bcache_str (struct macro_table *t, const char *s)
133 return macro_bcache (t, s, strlen (s) + 1);
137 /* Free a possibly bcached object OBJ. That is, if the macro table T
138 has a bcache, do nothing; otherwise, xfree OBJ. */
140 macro_bcache_free (struct macro_table *t, void *obj)
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
154 /* Macro tree keys, w/their comparison, allocation, and freeing functions. */
156 /* A key in the splay tree. */
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
163 struct macro_table *table;
165 /* The name of the macro. This is in the table's bcache, if it has
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;
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
178 struct macro_source_file *end_file;
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. */
188 inclusion_depth (struct macro_source_file *file)
192 for (depth = 0; file->included_by; depth++)
193 file = file->included_by;
199 /* Compare two source locations (from the same compilation unit).
200 This is part of the comparison function for the tree of
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.
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
215 compare_locations (struct macro_source_file *file1, int line1,
216 struct macro_source_file *file2, int line2)
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
227 /* If a file is zero, that means "end of compilation unit." Handle
239 /* If the two files are not the same, find their common ancestor in
240 the #inclusion tree. */
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);
250 /* Only one of these while loops will ever execute in any given
252 while (depth1 > depth2)
254 line1 = file1->included_at_line;
255 file1 = file1->included_by;
259 while (depth2 > depth1)
261 line2 = file2->included_at_line;
262 file2 = file2->included_by;
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)
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. */
278 line2 = file2->included_at_line;
279 file2 = file2->included_by;
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);
289 /* Now we've got two line numbers in the same file. */
292 /* They can't both be from #included files. Then we shouldn't
293 have walked up this far. */
294 gdb_assert (! included1 || ! included2);
296 /* Any #included position comes after a non-#included position
297 with the same line number in the #including file. */
306 return line1 - line2;
310 /* Compare a macro key KEY against NAME, the source file FILE, and
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.
317 Return -1, 0, or 1 if key comes before, is identical to, or comes
318 after NAME, FILE, and LINE. */
320 key_compare (struct macro_key *key,
321 const char *name, struct macro_source_file *file, int line)
323 int names = strcmp (key->name, name);
328 return compare_locations (key->start_file, key->start_line,
333 /* The macro tree comparison function, typed for the splay tree
334 library's happiness. */
336 macro_tree_compare (splay_tree_key untyped_key1,
337 splay_tree_key untyped_key2)
339 struct macro_key *key1 = (struct macro_key *) untyped_key1;
340 struct macro_key *key2 = (struct macro_key *) untyped_key2;
342 return key_compare (key1, key2->name, key2->start_file, key2->start_line);
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
349 static struct macro_key *
350 new_macro_key (struct macro_table *t,
352 struct macro_source_file *file,
355 struct macro_key *k = macro_alloc (sizeof (*k), t);
357 memset (k, 0, sizeof (*k));
359 k->name = macro_bcache_str (t, name);
360 k->start_file = file;
361 k->start_line = line;
369 macro_tree_delete_key (void *untyped_key)
371 struct macro_key *key = (struct macro_key *) untyped_key;
373 macro_bcache_free (key->table, (char *) key->name);
374 macro_free (key, key->table);
379 /* Building and querying the tree of #included files. */
382 /* Allocate and initialize a new source file structure. */
383 static struct macro_source_file *
384 new_source_file (struct macro_table *t,
385 const char *filename)
387 /* Get space for the source file structure itself. */
388 struct macro_source_file *f = macro_alloc (sizeof (*f), t);
390 memset (f, 0, sizeof (*f));
392 f->filename = macro_bcache_str (t, filename);
399 /* Free a source file, and all the source files it #included. */
401 free_macro_source_file (struct macro_source_file *src)
403 struct macro_source_file *child, *next_child;
405 /* Free this file's children. */
406 for (child = src->includes; child; child = next_child)
408 next_child = child->next_included;
409 free_macro_source_file (child);
412 macro_bcache_free (src->table, (char *) src->filename);
413 macro_free (src, src->table);
417 struct macro_source_file *
418 macro_set_main (struct macro_table *t,
419 const char *filename)
421 /* You can't change a table's main source file. What would that do
423 gdb_assert (! t->main_source);
425 t->main_source = new_source_file (t, filename);
427 return t->main_source;
431 struct macro_source_file *
432 macro_main (struct macro_table *t)
434 gdb_assert (t->main_source);
436 return t->main_source;
441 macro_allow_redefinitions (struct macro_table *t)
443 gdb_assert (! t->obstack);
448 struct macro_source_file *
449 macro_include (struct macro_source_file *source,
451 const char *included)
453 struct macro_source_file *newobj;
454 struct macro_source_file **link;
456 /* Find the right position in SOURCE's `includes' list for the new
457 file. Skip inclusions at earlier lines, until we find one at the
458 same line or later --- or until the end of the list. */
459 for (link = &source->includes;
460 *link && (*link)->included_at_line < line;
461 link = &(*link)->next_included)
464 /* Did we find another file already #included at the same line as
466 if (*link && line == (*link)->included_at_line)
468 char *link_fullname, *source_fullname;
470 /* This means the compiler is emitting bogus debug info. (GCC
471 circa March 2002 did this.) It also means that the splay
472 tree ordering function, macro_tree_compare, will abort,
473 because it can't tell which #inclusion came first. But GDB
474 should tolerate bad debug info. So:
478 link_fullname = macro_source_fullname (*link);
479 source_fullname = macro_source_fullname (source);
480 complaint (&symfile_complaints,
481 _("both `%s' and `%s' allegedly #included at %s:%d"),
482 included, link_fullname, source_fullname, line);
483 xfree (source_fullname);
484 xfree (link_fullname);
486 /* Now, choose a new, unoccupied line number for this
487 #inclusion, after the alleged #inclusion line. */
488 while (*link && line == (*link)->included_at_line)
490 /* This line number is taken, so try the next line. */
492 link = &(*link)->next_included;
496 /* At this point, we know that LINE is an unused line number, and
497 *LINK points to the entry an #inclusion at that line should
499 newobj = new_source_file (source->table, included);
500 newobj->included_by = source;
501 newobj->included_at_line = line;
502 newobj->next_included = *link;
509 struct macro_source_file *
510 macro_lookup_inclusion (struct macro_source_file *source, const char *name)
512 /* Is SOURCE itself named NAME? */
513 if (filename_cmp (name, source->filename) == 0)
516 /* It's not us. Try all our children, and return the lowest. */
518 struct macro_source_file *child;
519 struct macro_source_file *best = NULL;
522 for (child = source->includes; child; child = child->next_included)
524 struct macro_source_file *result
525 = macro_lookup_inclusion (child, name);
529 int result_depth = inclusion_depth (result);
531 if (! best || result_depth < best_depth)
534 best_depth = result_depth;
545 /* Registering and looking up macro definitions. */
548 /* Construct a definition for a macro in table T. Cache all strings,
549 and the macro_definition structure itself, in T's bcache. */
550 static struct macro_definition *
551 new_macro_definition (struct macro_table *t,
552 enum macro_kind kind,
553 int argc, const char **argv,
554 const char *replacement)
556 struct macro_definition *d = macro_alloc (sizeof (*d), t);
558 memset (d, 0, sizeof (*d));
561 d->replacement = macro_bcache_str (t, replacement);
564 if (kind == macro_function_like)
567 const char **cached_argv;
568 int cached_argv_size = argc * sizeof (*cached_argv);
570 /* Bcache all the arguments. */
571 cached_argv = alloca (cached_argv_size);
572 for (i = 0; i < argc; i++)
573 cached_argv[i] = macro_bcache_str (t, argv[i]);
575 /* Now bcache the array of argument pointers itself. */
576 d->argv = macro_bcache (t, cached_argv, cached_argv_size);
579 /* We don't bcache the entire definition structure because it's got
580 a pointer to the macro table in it; since each compilation unit
581 has its own macro table, you'd only get bcache hits for identical
582 definitions within a compilation unit, which seems unlikely.
584 "So, why do macro definitions have pointers to their macro tables
585 at all?" Well, when the splay tree library wants to free a
586 node's value, it calls the value freeing function with nothing
587 but the value itself. It makes the (apparently reasonable)
588 assumption that the value carries enough information to free
589 itself. But not all macro tables have bcaches, so not all macro
590 definitions would be bcached. There's no way to tell whether a
591 given definition is bcached without knowing which table the
592 definition belongs to. ... blah. The thing's only sixteen
593 bytes anyway, and we can still bcache the name, args, and
594 definition, so we just don't bother bcaching the definition
600 /* Free a macro definition. */
602 macro_tree_delete_value (void *untyped_definition)
604 struct macro_definition *d = (struct macro_definition *) untyped_definition;
605 struct macro_table *t = d->table;
607 if (d->kind == macro_function_like)
611 for (i = 0; i < d->argc; i++)
612 macro_bcache_free (t, (char *) d->argv[i]);
613 macro_bcache_free (t, (char **) d->argv);
616 macro_bcache_free (t, (char *) d->replacement);
621 /* Find the splay tree node for the definition of NAME at LINE in
622 SOURCE, or zero if there is none. */
623 static splay_tree_node
624 find_definition (const char *name,
625 struct macro_source_file *file,
628 struct macro_table *t = file->table;
631 /* Construct a macro_key object, just for the query. */
632 struct macro_key query;
635 query.start_file = file;
636 query.start_line = line;
637 query.end_file = NULL;
639 n = splay_tree_lookup (t->definitions, (splay_tree_key) &query);
642 /* It's okay for us to do two queries like this: the real work
643 of the searching is done when we splay, and splaying the tree
644 a second time at the same key is a constant time operation.
645 If this still bugs you, you could always just extend the
646 splay tree library with a predecessor-or-equal operation, and
648 splay_tree_node pred = splay_tree_predecessor (t->definitions,
649 (splay_tree_key) &query);
653 /* Make sure this predecessor actually has the right name.
654 We just want to search within a given name's definitions. */
655 struct macro_key *found = (struct macro_key *) pred->key;
657 if (strcmp (found->name, name) == 0)
664 struct macro_key *found = (struct macro_key *) n->key;
666 /* Okay, so this definition has the right name, and its scope
667 begins before the given source location. But does its scope
668 end after the given source location? */
669 if (compare_locations (file, line, found->end_file, found->end_line) < 0)
679 /* If NAME already has a definition in scope at LINE in SOURCE, return
680 the key. If the old definition is different from the definition
681 given by KIND, ARGC, ARGV, and REPLACEMENT, complain, too.
682 Otherwise, return zero. (ARGC and ARGV are meaningless unless KIND
683 is `macro_function_like'.) */
684 static struct macro_key *
685 check_for_redefinition (struct macro_source_file *source, int line,
686 const char *name, enum macro_kind kind,
687 int argc, const char **argv,
688 const char *replacement)
690 splay_tree_node n = find_definition (name, source, line);
694 struct macro_key *found_key = (struct macro_key *) n->key;
695 struct macro_definition *found_def
696 = (struct macro_definition *) n->value;
699 /* Is this definition the same as the existing one?
700 According to the standard, this comparison needs to be done
701 on lists of tokens, not byte-by-byte, as we do here. But
702 that's too hard for us at the moment, and comparing
703 byte-by-byte will only yield false negatives (i.e., extra
704 warning messages), not false positives (i.e., unnoticed
705 definition changes). */
706 if (kind != found_def->kind)
708 else if (strcmp (replacement, found_def->replacement))
710 else if (kind == macro_function_like)
712 if (argc != found_def->argc)
718 for (i = 0; i < argc; i++)
719 if (strcmp (argv[i], found_def->argv[i]))
726 char *source_fullname, *found_key_fullname;
728 source_fullname = macro_source_fullname (source);
729 found_key_fullname = macro_source_fullname (found_key->start_file);
730 complaint (&symfile_complaints,
731 _("macro `%s' redefined at %s:%d; "
732 "original definition at %s:%d"),
733 name, source_fullname, line, found_key_fullname,
734 found_key->start_line);
735 xfree (found_key_fullname);
736 xfree (source_fullname);
745 /* A helper function to define a new object-like macro. */
748 macro_define_object_internal (struct macro_source_file *source, int line,
749 const char *name, const char *replacement,
750 enum macro_special_kind kind)
752 struct macro_table *t = source->table;
753 struct macro_key *k = NULL;
754 struct macro_definition *d;
757 k = check_for_redefinition (source, line,
758 name, macro_object_like,
762 /* If we're redefining a symbol, and the existing key would be
763 identical to our new key, then the splay_tree_insert function
764 will try to delete the old definition. When the definition is
765 living on an obstack, this isn't a happy thing.
767 Since this only happens in the presence of questionable debug
768 info, we just ignore all definitions after the first. The only
769 case I know of where this arises is in GCC's output for
770 predefined macros, and all the definitions are the same in that
772 if (k && ! key_compare (k, name, source, line))
775 k = new_macro_key (t, name, source, line);
776 d = new_macro_definition (t, macro_object_like, kind, 0, replacement);
777 splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
781 macro_define_object (struct macro_source_file *source, int line,
782 const char *name, const char *replacement)
784 macro_define_object_internal (source, line, name, replacement,
788 /* See macrotab.h. */
791 macro_define_special (struct macro_table *table)
793 macro_define_object_internal (table->main_source, -1, "__FILE__", "",
795 macro_define_object_internal (table->main_source, -1, "__LINE__", "",
800 macro_define_function (struct macro_source_file *source, int line,
801 const char *name, int argc, const char **argv,
802 const char *replacement)
804 struct macro_table *t = source->table;
805 struct macro_key *k = NULL;
806 struct macro_definition *d;
809 k = check_for_redefinition (source, line,
810 name, macro_function_like,
814 /* See comments about duplicate keys in macro_define_object. */
815 if (k && ! key_compare (k, name, source, line))
818 /* We should also check here that all the argument names in ARGV are
821 k = new_macro_key (t, name, source, line);
822 d = new_macro_definition (t, macro_function_like, argc, argv, replacement);
823 splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
828 macro_undef (struct macro_source_file *source, int line,
831 splay_tree_node n = find_definition (name, source, line);
835 struct macro_key *key = (struct macro_key *) n->key;
837 /* If we're removing a definition at exactly the same point that
838 we defined it, then just delete the entry altogether. GCC
839 4.1.2 will generate DWARF that says to do this if you pass it
840 arguments like '-DFOO -UFOO -DFOO=2'. */
841 if (source == key->start_file
842 && line == key->start_line)
843 splay_tree_remove (source->table->definitions, n->key);
847 /* This function is the only place a macro's end-of-scope
848 location gets set to anything other than "end of the
849 compilation unit" (i.e., end_file is zero). So if this
850 macro already has its end-of-scope set, then we're
851 probably seeing a second #undefinition for the same
855 char *source_fullname, *key_fullname;
857 source_fullname = macro_source_fullname (source);
858 key_fullname = macro_source_fullname (key->end_file);
859 complaint (&symfile_complaints,
860 _("macro '%s' is #undefined twice,"
861 " at %s:%d and %s:%d"),
862 name, source_fullname, line, key_fullname,
864 xfree (key_fullname);
865 xfree (source_fullname);
868 /* Whether or not we've seen a prior #undefinition, wipe out
869 the old ending point, and make this the ending point. */
870 key->end_file = source;
871 key->end_line = line;
876 /* According to the ISO C standard, an #undef for a symbol that
877 has no macro definition in scope is ignored. So we should
880 complaint (&symfile_complaints,
881 _("no definition for macro `%s' in scope to #undef at %s:%d"),
882 name, source->filename, line);
887 /* A helper function that rewrites the definition of a special macro,
890 static struct macro_definition *
891 fixup_definition (const char *filename, int line, struct macro_definition *def)
893 static char *saved_expansion;
897 xfree (saved_expansion);
898 saved_expansion = NULL;
901 if (def->kind == macro_object_like)
903 if (def->argc == macro_FILE)
905 saved_expansion = macro_stringify (filename);
906 def->replacement = saved_expansion;
908 else if (def->argc == macro_LINE)
910 saved_expansion = xstrprintf ("%d", line);
911 def->replacement = saved_expansion;
918 struct macro_definition *
919 macro_lookup_definition (struct macro_source_file *source,
920 int line, const char *name)
922 splay_tree_node n = find_definition (name, source, line);
926 struct macro_definition *retval;
927 char *source_fullname;
929 source_fullname = macro_source_fullname (source);
930 retval = fixup_definition (source_fullname, line,
931 (struct macro_definition *) n->value);
932 xfree (source_fullname);
940 struct macro_source_file *
941 macro_definition_location (struct macro_source_file *source,
944 int *definition_line)
946 splay_tree_node n = find_definition (name, source, line);
950 struct macro_key *key = (struct macro_key *) n->key;
952 *definition_line = key->start_line;
953 return key->start_file;
960 /* The type for callback data for iterating the splay tree in
961 macro_for_each and macro_for_each_in_scope. Only the latter uses
962 the FILE and LINE fields. */
963 struct macro_for_each_data
965 macro_callback_fn fn;
967 struct macro_source_file *file;
971 /* Helper function for macro_for_each. */
973 foreach_macro (splay_tree_node node, void *arg)
975 struct macro_for_each_data *datum = (struct macro_for_each_data *) arg;
976 struct macro_key *key = (struct macro_key *) node->key;
977 struct macro_definition *def;
980 key_fullname = macro_source_fullname (key->start_file);
981 def = fixup_definition (key_fullname, key->start_line,
982 (struct macro_definition *) node->value);
983 xfree (key_fullname);
985 (*datum->fn) (key->name, def, key->start_file, key->start_line,
990 /* Call FN for every macro in TABLE. */
992 macro_for_each (struct macro_table *table, macro_callback_fn fn,
995 struct macro_for_each_data datum;
998 datum.user_data = user_data;
1001 splay_tree_foreach (table->definitions, foreach_macro, &datum);
1005 foreach_macro_in_scope (splay_tree_node node, void *info)
1007 struct macro_for_each_data *datum = (struct macro_for_each_data *) info;
1008 struct macro_key *key = (struct macro_key *) node->key;
1009 struct macro_definition *def;
1010 char *datum_fullname;
1012 datum_fullname = macro_source_fullname (datum->file);
1013 def = fixup_definition (datum_fullname, datum->line,
1014 (struct macro_definition *) node->value);
1015 xfree (datum_fullname);
1017 /* See if this macro is defined before the passed-in line, and
1018 extends past that line. */
1019 if (compare_locations (key->start_file, key->start_line,
1020 datum->file, datum->line) < 0
1022 || compare_locations (key->end_file, key->end_line,
1023 datum->file, datum->line) >= 0))
1024 (*datum->fn) (key->name, def, key->start_file, key->start_line,
1029 /* Call FN for every macro is visible in SCOPE. */
1031 macro_for_each_in_scope (struct macro_source_file *file, int line,
1032 macro_callback_fn fn, void *user_data)
1034 struct macro_for_each_data datum;
1037 datum.user_data = user_data;
1040 splay_tree_foreach (file->table->definitions,
1041 foreach_macro_in_scope, &datum);
1046 /* Creating and freeing macro tables. */
1049 struct macro_table *
1050 new_macro_table (struct obstack *obstack, struct bcache *b,
1051 struct compunit_symtab *cust)
1053 struct macro_table *t;
1055 /* First, get storage for the `struct macro_table' itself. */
1057 t = XOBNEW (obstack, struct macro_table);
1059 t = XNEW (struct macro_table);
1061 memset (t, 0, sizeof (*t));
1062 t->obstack = obstack;
1064 t->main_source = NULL;
1065 t->compunit_symtab = cust;
1067 t->definitions = (splay_tree_new_with_allocator
1068 (macro_tree_compare,
1069 ((splay_tree_delete_key_fn) macro_tree_delete_key),
1070 ((splay_tree_delete_value_fn) macro_tree_delete_value),
1071 ((splay_tree_allocate_fn) macro_alloc),
1072 ((splay_tree_deallocate_fn) macro_free),
1080 free_macro_table (struct macro_table *table)
1082 /* Free the source file tree. */
1083 free_macro_source_file (table->main_source);
1085 /* Free the table of macro definitions. */
1086 splay_tree_delete (table->definitions);
1089 /* See macrotab.h for the comment. */
1092 macro_source_fullname (struct macro_source_file *file)
1094 const char *comp_dir = NULL;
1096 if (file->table->compunit_symtab != NULL)
1097 comp_dir = COMPUNIT_DIRNAME (file->table->compunit_symtab);
1099 if (comp_dir == NULL || IS_ABSOLUTE_PATH (file->filename))
1100 return xstrdup (file->filename);
1102 return concat (comp_dir, SLASH_STRING, file->filename, NULL);