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