PR macros/12999
[external/binutils.git] / gdb / macrotab.c
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 \f
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 \f
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 \f
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 \f
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 \f
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, key->start_file, key->start_line,
917                 datum->user_data);
918   return 0;
919 }
920
921 /* Call FN for every macro in TABLE.  */
922 void
923 macro_for_each (struct macro_table *table, macro_callback_fn fn,
924                 void *user_data)
925 {
926   struct macro_for_each_data datum;
927
928   datum.fn = fn;
929   datum.user_data = user_data;
930   datum.file = NULL;
931   datum.line = 0;
932   splay_tree_foreach (table->definitions, foreach_macro, &datum);
933 }
934
935 static int
936 foreach_macro_in_scope (splay_tree_node node, void *info)
937 {
938   struct macro_for_each_data *datum = (struct macro_for_each_data *) info;
939   struct macro_key *key = (struct macro_key *) node->key;
940   struct macro_definition *def = (struct macro_definition *) node->value;
941
942   /* See if this macro is defined before the passed-in line, and
943      extends past that line.  */
944   if (compare_locations (key->start_file, key->start_line,
945                          datum->file, datum->line) < 0
946       && (!key->end_file
947           || compare_locations (key->end_file, key->end_line,
948                                 datum->file, datum->line) >= 0))
949     (*datum->fn) (key->name, def, key->start_file, key->start_line,
950                   datum->user_data);
951   return 0;
952 }
953
954 /* Call FN for every macro is visible in SCOPE.  */
955 void
956 macro_for_each_in_scope (struct macro_source_file *file, int line,
957                          macro_callback_fn fn, void *user_data)
958 {
959   struct macro_for_each_data datum;
960
961   datum.fn = fn;
962   datum.user_data = user_data;
963   datum.file = file;
964   datum.line = line;
965   splay_tree_foreach (file->table->definitions,
966                       foreach_macro_in_scope, &datum);
967 }
968
969
970 \f
971 /* Creating and freeing macro tables.  */
972
973
974 struct macro_table *
975 new_macro_table (struct obstack *obstack,
976                  struct bcache *b)
977 {
978   struct macro_table *t;
979
980   /* First, get storage for the `struct macro_table' itself.  */
981   if (obstack)
982     t = obstack_alloc (obstack, sizeof (*t));
983   else
984     t = xmalloc (sizeof (*t));
985
986   memset (t, 0, sizeof (*t));
987   t->obstack = obstack;
988   t->bcache = b;
989   t->main_source = NULL;
990   t->redef_ok = 0;
991   t->definitions = (splay_tree_new_with_allocator
992                     (macro_tree_compare,
993                      ((splay_tree_delete_key_fn) macro_tree_delete_key),
994                      ((splay_tree_delete_value_fn) macro_tree_delete_value),
995                      ((splay_tree_allocate_fn) macro_alloc),
996                      ((splay_tree_deallocate_fn) macro_free),
997                      t));
998   
999   return t;
1000 }
1001
1002
1003 void
1004 free_macro_table (struct macro_table *table)
1005 {
1006   /* Free the source file tree.  */
1007   free_macro_source_file (table->main_source);
1008
1009   /* Free the table of macro definitions.  */
1010   splay_tree_delete (table->definitions);
1011 }