OSDN Git Service

Support expansion of reserved locations wrapped in virtual locations
[pf3gnuchains/gcc-fork.git] / libcpp / include / line-map.h
1 /* Map logical line numbers to (source file, line number) pairs.
2    Copyright (C) 2001, 2003, 2004, 2007, 2008, 2009, 2010, 2011
3    Free Software Foundation, Inc.
4
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 3, or (at your option) any
8 later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3.  If not see
17 <http://www.gnu.org/licenses/>.
18
19  In other words, you are welcome to use, share and improve this program.
20  You are forbidden to forbid anyone else to use, share and improve
21  what you give them.   Help stamp out software-hoarding!  */
22
23 #ifndef LIBCPP_LINE_MAP_H
24 #define LIBCPP_LINE_MAP_H
25
26 #ifndef GTY
27 #define GTY(x) /* nothing */
28 #endif
29
30 /* Reason for creating a new line map with linemap_add.  LC_ENTER is
31    when including a new file, e.g. a #include directive in C.
32    LC_LEAVE is when reaching a file's end.  LC_RENAME is when a file
33    name or line number changes for neither of the above reasons
34    (e.g. a #line directive in C); LC_RENAME_VERBATIM is like LC_RENAME
35    but a filename of "" is not specially interpreted as standard
36    input. LC_ENTER_MACRO is when a macro expansion is about to start.  */
37 enum lc_reason
38 {
39   LC_ENTER = 0,
40   LC_LEAVE,
41   LC_RENAME,
42   LC_RENAME_VERBATIM,
43   LC_ENTER_MACRO
44   /* FIXME: add support for stringize and paste.  */
45 };
46
47 /* The type of line numbers.  */
48 typedef unsigned int linenum_type;
49
50 /* A logical line/column number, i.e. an "index" into a line_map.  */
51 typedef unsigned int source_location;
52
53 /* Memory allocation function typedef.  Works like xrealloc.  */
54 typedef void *(*line_map_realloc) (void *, size_t);
55
56 /* Memory allocator function that returns the actual allocated size,
57    for a given requested allocation.  */
58 typedef size_t (*line_map_round_alloc_size_func) (size_t);
59
60 /* An ordinary line map encodes physical source locations. Those
61    physical source locations are called "spelling locations".
62    
63    Physical source file TO_FILE at line TO_LINE at column 0 is represented
64    by the logical START_LOCATION.  TO_LINE+L at column C is represented by
65    START_LOCATION+(L*(1<<column_bits))+C, as long as C<(1<<column_bits),
66    and the result_location is less than the next line_map's start_location.
67    (The top line is line 1 and the leftmost column is column 1; line/column 0
68    means "entire file/line" or "unknown line/column" or "not applicable".)
69
70    The highest possible source location is MAX_SOURCE_LOCATION.  */
71 struct GTY(()) line_map_ordinary {
72   const char *to_file;
73   linenum_type to_line;
74
75   /* An index into the set that gives the line mapping at whose end
76      the current one was included.  File(s) at the bottom of the
77      include stack have this set to -1.  */
78   int included_from;
79
80   /* SYSP is one for a system header, two for a C system header file
81      that therefore needs to be extern "C" protected in C++, and zero
82      otherwise.  This field isn't really needed now that it's in
83      cpp_buffer.  */
84   unsigned char sysp;
85
86   /* Number of the low-order source_location bits used for a column number.  */
87   unsigned int column_bits : 8;
88 };
89
90 /* This is the highest possible source location encoded within an
91    ordinary or macro map.  */
92 #define MAX_SOURCE_LOCATION 0xFFFFFFFF
93
94 struct cpp_hashnode;
95
96 /* A macro line map encodes location of tokens coming from a macro
97    expansion.
98    
99    Please note that this struct line_map_macro is a field of struct
100    line_map below, go read the comments of struct line_map below and
101    then come back here.
102    
103    The offset from START_LOCATION is used to index into
104    MACRO_LOCATIONS; this holds the original location of the token.  */
105 struct GTY(()) line_map_macro {
106   /* The cpp macro which expansion gave birth to this macro map.  */
107   struct cpp_hashnode * GTY ((nested_ptr (union tree_node,
108                                    "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
109                                    "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
110     macro;
111
112   /* The number of tokens inside the replacement-list of MACRO.  */
113   unsigned int n_tokens;
114
115   /* This array of location is actually an array of pairs of
116      locations. The elements inside it thus look like:
117
118            x0,y0, x1,y1, x2,y2, ...., xn,yn.
119
120      where n == n_tokens;
121
122      Remember that these xI,yI are collected when libcpp is about to
123      expand a given macro.
124
125      yI is the location in the macro definition, either of the token
126      itself or of a macro parameter that it replaces.
127
128      Imagine this:
129
130         #define PLUS(A, B) A + B  <--- #1
131
132         int a = PLUS (1,2); <--- #2
133
134      There is a macro map for the expansion of PLUS in #2.  PLUS is
135      expanded into its expansion-list.  The expansion-list is the
136      replacement-list of PLUS where the macro parameters are replaced
137      with their arguments.  So the replacement-list of PLUS is made of
138      the tokens:
139
140         A, +, B
141
142      and the expansion-list is made of the tokens:
143
144         1, +, 2
145
146      Let's consider the case of token "+".  Its y1 [yI for I == 1] is
147      its spelling location in #1.
148
149      y0 (thus for token "1") is the spelling location of A in #1.
150
151      And y2 (of token "2") is the spelling location of B in #1.
152
153      When the token is /not/ an argument for a macro, xI is the same
154      location as yI.  Otherwise, xI is the location of the token
155      outside this macro expansion.  If this macro was expanded from
156      another macro expansion, xI is a virtual location representing
157      the token in that macro expansion; otherwise, it is the spelling
158      location of the token.
159
160      Note that a virtual location is a location returned by
161      linemap_add_macro_token.  It encodes the relevant locations (x,y
162      pairs) of that token accross the macro expansions from which it
163      (the token) might come from.
164
165      In the example above x1 (for token "+") is going to be the same
166      as y1.  x0 is the spelling location for the argument token "1",
167      and x2 is the spelling location for the argument token "2".  */
168   source_location * GTY((length ("2 * %h.n_tokens"))) macro_locations;
169
170   /* This is the location of the expansion point of the current macro
171      map.  It's the location of the macro name.  That location is held
172      by the map that was current right before the current one. It
173      could have been either a macro or an ordinary map, depending on
174      if we are in a nested expansion context not.  */
175   source_location expansion;
176 };
177
178 /* A line_map encodes a sequence of locations.
179    There are two kinds of maps. Ordinary maps and macro expansion
180    maps, a.k.a macro maps.
181
182    A macro map encodes source locations of tokens that are part of a
183    macro replacement-list, at a macro expansion point. E.g, in:
184
185             #define PLUS(A,B) A + B
186
187    No macro map is going to be created there, because we are not at a
188    macro expansion point. We are at a macro /definition/ point. So the
189    locations of the tokens of the macro replacement-list (i.e, A + B)
190    will be locations in an ordinary map, not a macro map.
191
192    On the other hand, if we later do:
193
194         int a = PLUS (1,2);
195
196    The invocation of PLUS here is a macro expansion. So we are at a
197    macro expansion point. The preprocessor expands PLUS (1,2) and
198    replaces it with the tokens of its replacement-list: 1 + 2. A macro
199    map is going to be created to hold (or rather to map, haha ...) the
200    locations of the tokens 1, + and 2. The macro map also records the
201    location of the expansion point of PLUS. That location is mapped in
202    the map that is active right before the location of the invocation
203    of PLUS.  */
204 struct GTY(()) line_map {
205   source_location start_location;
206
207   /* The reason for creation of this line map.  */
208   ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
209
210   union map_u {
211     struct line_map_ordinary GTY((tag ("0"))) ordinary;
212     struct line_map_macro GTY((tag ("1"))) macro;
213   } GTY((desc ("%1.reason == LC_ENTER_MACRO"))) d;
214 };
215
216 #define MAP_START_LOCATION(MAP) (MAP)->start_location
217
218 #define ORDINARY_MAP_FILE_NAME(MAP) \
219   linemap_check_ordinary (MAP)->d.ordinary.to_file
220
221 #define ORDINARY_MAP_STARTING_LINE_NUMBER(MAP) \
222   linemap_check_ordinary (MAP)->d.ordinary.to_line
223
224 #define ORDINARY_MAP_INCLUDER_FILE_INDEX(MAP) \
225   linemap_check_ordinary (MAP)->d.ordinary.included_from
226
227 #define ORDINARY_MAP_IN_SYSTEM_HEADER_P(MAP) \
228   linemap_check_ordinary (MAP)->d.ordinary.sysp
229
230 #define ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(MAP) \
231   linemap_check_ordinary (MAP)->d.ordinary.column_bits
232
233 #define MACRO_MAP_MACRO(MAP) (MAP)->d.macro.macro
234
235 #define MACRO_MAP_NUM_MACRO_TOKENS(MAP) (MAP)->d.macro.n_tokens
236
237 #define MACRO_MAP_LOCATIONS(MAP) (MAP)->d.macro.macro_locations
238
239 #define MACRO_MAP_EXPANSION_POINT_LOCATION(MAP) (MAP)->d.macro.expansion
240
241 /* The abstraction of a set of location maps. There can be several
242    types of location maps. This abstraction contains the attributes
243    that are independent from the type of the map.  */
244 struct GTY(()) maps_info {
245   /* This array contains the different line maps.
246      A line map is created for the following events:
247        - when a new preprocessing unit start. 
248        - when a preprocessing unit ends.
249        - when a macro expansion occurs.  */
250   struct line_map * GTY ((length ("%h.used"))) maps;
251
252   /* The total number of allocated maps.  */
253   unsigned int allocated;
254
255   /* The number of elements used in maps. This number is smaller
256      or equal to ALLOCATED.  */
257   unsigned int used;
258
259   unsigned int cache;
260 };
261
262 /* A set of chronological line_map structures.  */
263 struct GTY(()) line_maps {
264   
265   struct maps_info info_ordinary;
266
267   struct maps_info info_macro;
268
269   /* Depth of the include stack, including the current file.  */
270   unsigned int depth;
271
272   /* If true, prints an include trace a la -H.  */
273   bool trace_includes;
274
275   /* Highest source_location "given out".  */
276   source_location highest_location;
277
278   /* Start of line of highest source_location "given out".  */
279   source_location highest_line;
280
281   /* The maximum column number we can quickly allocate.  Higher numbers
282      may require allocating a new line_map.  */
283   unsigned int max_column_hint;
284
285   /* If non-null, the allocator to use when resizing 'maps'.  If null,
286      xrealloc is used.  */
287   line_map_realloc reallocator;
288
289   /* The allocators' function used to know the actual size it
290      allocated, for a certain allocation size requested.  */
291   line_map_round_alloc_size_func round_alloc_size;
292 };
293
294 /* Returns the pointer to the memory region where information about
295    maps are stored in the line table SET. MACRO_MAP_P is a flag
296    telling if we want macro or ordinary maps.  */
297 #define LINEMAPS_MAP_INFO(SET, MACRO_MAP_P)                             \
298   ((MACRO_MAP_P)                                                        \
299    ? &((SET)->info_macro)                                               \
300    : &((SET)->info_ordinary))
301
302 /* Returns the pointer to the memory region where maps are stored in
303    the line table SET. MAP_KIND shall be TRUE if we are interested in
304    macro maps false otherwise.  */
305 #define LINEMAPS_MAPS(SET, MAP_KIND) \
306   (LINEMAPS_MAP_INFO (SET, MAP_KIND))->maps
307
308 /* Returns the number of allocated maps so far. MAP_KIND shall be TRUE
309    if we are interested in macro maps, FALSE otherwise.  */
310 #define LINEMAPS_ALLOCATED(SET, MAP_KIND) \
311   (LINEMAPS_MAP_INFO (SET, MAP_KIND))->allocated
312
313 /* Returns the number of used maps so far. MAP_KIND shall be TRUE if
314    we are interested in macro maps, FALSE otherwise.*/
315 #define LINEMAPS_USED(SET, MAP_KIND) \
316   (LINEMAPS_MAP_INFO (SET, MAP_KIND))->used
317
318 /* Returns the index of the last map that was looked up with
319    linemap_lookup. MAP_KIND shall be TRUE if we are interested in
320    macro maps, FALSE otherwise.  */
321 #define LINEMAPS_CACHE(SET, MAP_KIND) \
322   (LINEMAPS_MAP_INFO (SET, MAP_KIND))->cache
323
324 /* Return the map at a given index.  */
325 #define LINEMAPS_MAP_AT(SET, MAP_KIND, INDEX)   \
326   (&((LINEMAPS_MAPS (SET, MAP_KIND))[(INDEX)]))
327
328 /* Returns the last map used in the line table SET. MAP_KIND
329    shall be TRUE if we are interested in macro maps, FALSE
330    otherwise.*/
331 #define LINEMAPS_LAST_MAP(SET, MAP_KIND) \
332   LINEMAPS_MAP_AT (SET, MAP_KIND, (LINEMAPS_USED (SET, MAP_KIND) - 1))
333
334 /* Returns the last map that was allocated in the line table SET.
335    MAP_KIND shall be TRUE if we are interested in macro maps, FALSE
336    otherwise.*/
337 #define LINEMAPS_LAST_ALLOCATED_MAP(SET, MAP_KIND) \
338   LINEMAPS_MAP_AT (SET, MAP_KIND, LINEMAPS_ALLOCATED (SET, MAP_KIND) - 1)
339
340 /* Returns a pointer to the memory region where ordinary maps are
341    allocated in the line table SET.  */
342 #define LINEMAPS_ORDINARY_MAPS(SET) \
343   LINEMAPS_MAPS (SET, false)
344
345 /* Returns the INDEXth ordinary map.  */
346 #define LINEMAPS_ORDINARY_MAP_AT(SET, INDEX)    \
347   LINEMAPS_MAP_AT (SET, false, INDEX)
348
349 /* Return the number of ordinary maps allocated in the line table
350    SET.  */
351 #define LINEMAPS_ORDINARY_ALLOCATED(SET) \
352   LINEMAPS_ALLOCATED(SET, false)
353
354 /* Return the number of ordinary maps used in the line table SET.  */
355 #define LINEMAPS_ORDINARY_USED(SET) \
356   LINEMAPS_USED(SET, false)
357
358 /* Return the index of the last ordinary map that was looked up with
359    linemap_lookup.  */
360 #define LINEMAPS_ORDINARY_CACHE(SET) \
361   LINEMAPS_CACHE(SET, false)
362
363 /* Returns a pointer to the last ordinary map used in the line table
364    SET.  */
365 #define LINEMAPS_LAST_ORDINARY_MAP(SET) \
366   LINEMAPS_LAST_MAP(SET, false)
367
368 /* Returns a pointer to the last ordinary map allocated the line table
369    SET.  */
370 #define LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP(SET) \
371   LINEMAPS_LAST_ALLOCATED_MAP(SET, false)
372
373 /* Returns a pointer to the begining of the region where macro maps
374    are allcoated.  */
375 #define LINEMAPS_MACRO_MAPS(SET) \
376   LINEMAPS_MAPS(SET, true)
377
378 /* Returns the INDEXth macro map.  */
379 #define LINEMAPS_MACRO_MAP_AT(SET, INDEX)       \
380   LINEMAPS_MAP_AT (SET, true, INDEX)
381
382 /* Returns the number of macro maps that were allocated in the line
383    table SET.  */
384 #define LINEMAPS_MACRO_ALLOCATED(SET) \
385   LINEMAPS_ALLOCATED(SET, true)
386
387 /* Returns the number of macro maps used in the line table SET.  */
388 #define LINEMAPS_MACRO_USED(SET) \
389   LINEMAPS_USED(SET, true)
390
391 /* Returns the index of the last macro map looked up with
392    linemap_lookup.  */
393 #define LINEMAPS_MACRO_CACHE(SET) \
394   LINEMAPS_CACHE(SET, true)
395
396 /* Returns the lowest location [of a token resulting from macro
397    expansion] encoded in this line table.  */
398 #define LINEMAPS_MACRO_LOWEST_LOCATION(SET)                     \
399   (LINEMAPS_MACRO_USED (set)                                    \
400    ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set))         \
401    : MAX_SOURCE_LOCATION)
402
403 /* Returns the last macro map used in the line table SET.  */
404 #define LINEMAPS_LAST_MACRO_MAP(SET) \
405   LINEMAPS_LAST_MAP (SET, true)
406
407 /* Returns the last macro map allocated in the line table SET.  */
408 #define LINEMAPS_LAST_ALLOCATED_MACRO_MAP(SET) \
409   LINEMAPS_LAST_ALLOCATED_MAP (SET, true)
410
411 /* Initialize a line map set.  */
412 extern void linemap_init (struct line_maps *);
413
414 /* Check for and warn about line_maps entered but not exited.  */
415
416 extern void linemap_check_files_exited (struct line_maps *);
417
418 /* Return a source_location for the start (i.e. column==0) of
419    (physical) line TO_LINE in the current source file (as in the
420    most recent linemap_add).   MAX_COLUMN_HINT is the highest column
421    number we expect to use in this line (but it does not change
422    the highest_location).  */
423
424 extern source_location linemap_line_start
425 (struct line_maps *set, linenum_type to_line,  unsigned int max_column_hint);
426
427 /* Add a mapping of logical source line to physical source file and
428    line number. This function creates an "ordinary map", which is a
429    map that records locations of tokens that are not part of macro
430    replacement-lists present at a macro expansion point.
431
432    The text pointed to by TO_FILE must have a lifetime
433    at least as long as the lifetime of SET.  An empty
434    TO_FILE means standard input.  If reason is LC_LEAVE, and
435    TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
436    natural values considering the file we are returning to.
437
438    A call to this function can relocate the previous set of
439    maps, so any stored line_map pointers should not be used.  */
440 extern const struct line_map *linemap_add
441   (struct line_maps *, enum lc_reason, unsigned int sysp,
442    const char *to_file, linenum_type to_line);
443
444 /* Given a logical source location, returns the map which the
445    corresponding (source file, line, column) triplet can be deduced
446    from. Since the set is built chronologically, the logical lines are
447    monotonic increasing, and so the list is sorted and we can use a
448    binary search. If no line map have been allocated yet, this
449    function returns NULL.  */
450 extern const struct line_map *linemap_lookup
451   (struct line_maps *, source_location);
452
453 /* Returns TRUE if the line table set tracks token locations accross
454    macro expansion, FALSE otherwise.  */
455 bool linemap_tracks_macro_expansion_locs_p (struct line_maps *);
456
457 /* Return TRUE if MAP encodes locations coming from a macro
458    replacement-list at macro expansion point.  */
459 bool linemap_macro_expansion_map_p (const struct line_map *);
460
461 /* Return the name of the macro associated to MACRO_MAP.  */
462 const char* linemap_map_get_macro_name (const struct line_map*);
463
464 /* Return a positive value if LOCATION is the locus of a token that is
465    located in a system header, O otherwise. It returns 1 if LOCATION
466    is the locus of a token that is located in a system header, and 2
467    if LOCATION is the locus of a token located in a C system header
468    that therefore needs to be extern "C" protected in C++.
469
470    Note that this function returns 1 if LOCATION belongs to a token
471    that is part of a macro replacement-list defined in a system
472    header, but expanded in a non-system file.  */
473 int linemap_location_in_system_header_p (struct line_maps *,
474                                          source_location);
475
476 /* Return TRUE if LOCATION is a source code location of a token coming
477    from a macro replacement-list at a macro expansion point, FALSE
478    otherwise.  */
479 bool linemap_location_from_macro_expansion_p (struct line_maps *,
480                                               source_location);
481
482 /* source_location values from 0 to RESERVED_LOCATION_COUNT-1 will
483    be reserved for libcpp user as special values, no token from libcpp
484    will contain any of those locations.  */
485 #define RESERVED_LOCATION_COUNT 2
486
487 /* Converts a map and a source_location to source line.  */
488 #define SOURCE_LINE(MAP, LOC)                                           \
489   (((((LOC) - linemap_check_ordinary (MAP)->start_location)             \
490      >> (MAP)->d.ordinary.column_bits) + (MAP)->d.ordinary.to_line))
491
492 /* Convert a map and source_location to source column number.  */
493 #define SOURCE_COLUMN(MAP, LOC)                                         \
494   ((((LOC) - linemap_check_ordinary (MAP)->start_location)              \
495     & ((1 << (MAP)->d.ordinary.column_bits) - 1)))
496
497 /* Returns the last source line number within an ordinary map.  This
498    is the (last) line of the #include, or other directive, that caused
499    a map change.  */
500 #define LAST_SOURCE_LINE(MAP) \
501   SOURCE_LINE (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
502
503 /* Return the last column number within an ordinary map.  */
504 #define LAST_SOURCE_COLUMN(MAP) \
505   SOURCE_COLUMN (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
506
507 /* Return the location of the last source line within an ordinary
508    map.  */
509 #define LAST_SOURCE_LINE_LOCATION(MAP)                                  \
510   ((((linemap_check_ordinary (MAP)[1].start_location - 1                \
511       - (MAP)->start_location)                                          \
512      & ~((1 << (MAP)->d.ordinary.column_bits) - 1))                     \
513     + (MAP)->start_location))
514
515 /* Returns the map a given map was included from, or NULL if the map
516    belongs to the main file, i.e, a file that wasn't included by
517    another one.  */
518 #define INCLUDED_FROM(SET, MAP)                                         \
519   ((linemap_check_ordinary (MAP)->d.ordinary.included_from == -1)       \
520    ? NULL                                                               \
521    : (&LINEMAPS_ORDINARY_MAPS (SET)[(MAP)->d.ordinary.included_from]))
522
523 /* Nonzero if the map is at the bottom of the include stack.  */
524 #define MAIN_FILE_P(MAP)                                                \
525   ((linemap_check_ordinary (MAP)->d.ordinary.included_from < 0))
526
527 #if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
528
529 /* Assertion macro to be used in line-map code.  */
530 #define linemap_assert(EXPR)                    \
531   do {                                          \
532     if (! (EXPR))                               \
533       abort ();                                 \
534   } while (0)
535
536 /* Assert that MAP encodes locations of tokens that are not part of
537    the replacement-list of a macro expansion.  */
538 #define linemap_check_ordinary(LINE_MAP) __extension__          \
539   ({linemap_assert (!linemap_macro_expansion_map_p (LINE_MAP)); \
540     (LINE_MAP);})
541 #else
542 #define linemap_assert(EXPR)
543 #define linemap_check_ordinary(LINE_MAP) (LINE_MAP)
544 #endif
545
546 /* Encode and return a source_location from a column number. The
547    source line considered is the last source line used to call
548    linemap_line_start, i.e, the last source line which a location was
549    encoded from.  */
550 extern source_location
551 linemap_position_for_column (struct line_maps *, unsigned int);
552
553 /* Encode and return a source location from a given line and
554    column.  */
555 source_location linemap_position_for_line_and_column (struct line_map *,
556                                                       linenum_type,
557                                                       unsigned int);
558 /* Return the file this map is for.  */
559 #define LINEMAP_FILE(MAP)                                       \
560   (linemap_check_ordinary (MAP)->d.ordinary.to_file)
561
562 /* Return the line number this map started encoding location from.  */
563 #define LINEMAP_LINE(MAP)                                       \
564   (linemap_check_ordinary (MAP)->d.ordinary.to_line)
565
566 /* Return a positive value if map encodes locations from a system
567    header, 0 otherwise. Returns 1 if MAP encodes locations in a
568    system header and 2 if it encodes locations in a C system header
569    that therefore needs to be extern "C" protected in C++.  */
570 #define LINEMAP_SYSP(MAP)                                       \
571   (linemap_check_ordinary (MAP)->d.ordinary.sysp)
572
573 /* Return a positive value if PRE denotes the location of a token that
574    comes before the token of POST, 0 if PRE denotes the location of
575    the same token as the token for POST, and a negative value
576    otherwise.  */
577 int linemap_compare_locations (struct line_maps *set,
578                                source_location   pre,
579                                source_location   post);
580
581 /* Return TRUE if LOC_A denotes the location a token that comes
582    topogically before the token denoted by location LOC_B, or if they
583    are equal.  */
584 #define linemap_location_before_p(SET, LOC_A, LOC_B)    \
585   (linemap_compare_locations ((SET), (LOC_A), (LOC_B)) >= 0)
586
587 typedef struct
588 {
589   /* The name of the source file involved.  */
590   const char *file;
591
592   /* The line-location in the source file.  */
593   int line;
594
595   int column;
596
597   /* In a system header?. */
598   bool sysp;
599 } expanded_location;
600
601 /* This is enum is used by the function linemap_resolve_location
602    below.  The meaning of the values is explained in the comment of
603    that function.  */
604 enum location_resolution_kind
605 {
606   LRK_MACRO_EXPANSION_POINT,
607   LRK_SPELLING_LOCATION,
608   LRK_MACRO_DEFINITION_LOCATION
609 };
610
611 /* Resolve a virtual location into either a spelling location, an
612    expansion point location or a token argument replacement point
613    location.  Return the map that encodes the virtual location as well
614    as the resolved location.
615
616    If LOC is *NOT* the location of a token resulting from the
617    expansion of a macro, then the parameter LRK (which stands for
618    Location Resolution Kind) is ignored and the resulting location
619    just equals the one given in argument.
620
621    Now if LOC *IS* the location of a token resulting from the
622    expansion of a macro, this is what happens.
623
624    * If LRK is set to LRK_MACRO_EXPANSION_POINT
625    -------------------------------
626
627    The virtual location is resolved to the first macro expansion point
628    that led to this macro expansion.
629
630    * If LRK is set to LRK_SPELLING_LOCATION
631    -------------------------------------
632
633    The virtual location is resolved to the locus where the token has
634    been spelled in the source.   This can follow through all the macro
635    expansions that led to the token.
636
637    * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
638    --------------------------------------
639
640    The virtual location is resolved to the locus of the token in the
641    context of the macro definition.
642
643    If LOC is the locus of a token that is an argument of a
644    function-like macro [replacing a parameter in the replacement list
645    of the macro] the virtual location is resolved to the locus of the
646    parameter that is replaced, in the context of the definition of the
647    macro.
648
649    If LOC is the locus of a token that is not an argument of a
650    function-like macro, then the function behaves as if LRK was set to
651    LRK_SPELLING_LOCATION.
652
653    If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the
654    returned location.  Note that if the resturned location wasn't originally
655    encoded by a map, the *MAP is set to NULL.  This can happen if LOC
656    resolves to a location reserved for the client code, like
657    UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC.  */
658
659 source_location linemap_resolve_location (struct line_maps *,
660                                           source_location loc,
661                                           enum location_resolution_kind lrk,
662                                           const struct line_map **loc_map);
663
664 /* Suppose that LOC is the virtual location of a token coming from the
665    expansion of a macro M.  This function then steps up to get the
666    location L of the point where M got expanded.  If L is a spelling
667    location inside a macro expansion M', then this function returns
668    the point where M' was expanded.  LOC_MAP is an output parameter.
669    When non-NULL, *LOC_MAP is set the the map of the returned
670    location.  */
671 source_location linemap_unwind_toward_expansion (struct line_maps *,
672                                                  source_location loc,
673                                                  const struct line_map **loc_map);
674
675 /* Expand source code location LOC and return a user readable source
676    code location.  LOC must be a spelling (non-virtual) location.  If
677    it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
678    location is returned.  */
679 expanded_location linemap_expand_location (struct line_maps *,
680                                            const struct line_map *,
681                                            source_location loc);
682
683 /* Statistics about maps allocation and usage as returned by
684    linemap_get_statistics.  */
685 struct linemap_stats
686 {
687   long num_ordinary_maps_allocated;
688   long num_ordinary_maps_used;
689   long ordinary_maps_allocated_size;
690   long ordinary_maps_used_size;
691   long num_expanded_macros;
692   long num_macro_tokens;
693   long num_macro_maps_used;
694   long macro_maps_allocated_size;
695   long macro_maps_used_size;
696   long macro_maps_locations_size;
697   long duplicated_macro_maps_locations_size;
698 };
699
700 /* Compute and return statistics about the memory consumption of some
701    parts of the line table SET.  */
702 void linemap_get_statistics (struct line_maps *, struct linemap_stats *);
703
704 /* Dump debugging information about source location LOC into the file
705    stream STREAM. SET is the line map set LOC comes from.  */
706 void linemap_dump_location (struct line_maps *, source_location, FILE *);
707
708 #endif /* !LIBCPP_LINE_MAP_H  */