1/* Map (unsigned int) keys to (source file, line, column) triples.
2 Copyright (C) 2001-2026 Free Software Foundation, Inc.
3
4This program is free software; you can redistribute it and/or modify it
5under the terms of the GNU General Public License as published by the
6Free Software Foundation; either version 3, or (at your option) any
7later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program; see the file COPYING3. If not see
16<http://www.gnu.org/licenses/>.
17
18 In other words, you are welcome to use, share and improve this program.
19 You are forbidden to forbid anyone else to use, share and improve
20 what you give them. Help stamp out software-hoarding! */
21
22#ifndef LIBCPP_LINE_MAP_H
23#define LIBCPP_LINE_MAP_H
24
25#include <utility>
26
27#ifndef GTY
28#define GTY(x) /* nothing */
29#endif
30
31/* Both gcc and emacs number source *lines* starting at 1, but
32 they have differing conventions for *columns*.
33
34 GCC uses a 1-based convention for source columns,
35 whereas Emacs's M-x column-number-mode uses a 0-based convention.
36
37 For example, an error in the initial, left-hand
38 column of source line 3 is reported by GCC as:
39
40 some-file.c:3:1: error: ...etc...
41
42 On navigating to the location of that error in Emacs
43 (e.g. via "next-error"),
44 the locus is reported in the Mode Line
45 (assuming M-x column-number-mode) as:
46
47 some-file.c 10% (3, 0)
48
49 i.e. "3:1:" in GCC corresponds to "(3, 0)" in Emacs. */
50
51/* The type of line numbers. */
52typedef unsigned int linenum_type;
53
54/* A type for doing arithmetic on line numbers. */
55typedef long long linenum_arith_t;
56
57/* A function for for use by qsort for comparing line numbers. */
58
59inline int compare (linenum_type lhs, linenum_type rhs)
60{
61 /* Avoid truncation issues by using linenum_arith_t for the comparison,
62 and only consider the sign of the result. */
63 linenum_arith_t diff = (linenum_arith_t)lhs - (linenum_arith_t)rhs;
64 if (diff)
65 return diff > 0 ? 1 : -1;
66 return 0;
67}
68
69/* Reason for creating a new line map with linemap_add. */
70enum lc_reason
71{
72 LC_ENTER = 0, /* Begin #include. */
73 LC_LEAVE, /* Return to including file. */
74 LC_RENAME, /* Other reason for name change. */
75 LC_RENAME_VERBATIM, /* Likewise, but "" != stdin. */
76 LC_ENTER_MACRO, /* Begin macro expansion. */
77 LC_MODULE, /* A (C++) Module. */
78 /* FIXME: add support for stringize and paste. */
79 LC_HWM /* High Water Mark. */
80};
81
82/* The typedef "location_t" is a key within the location database,
83 identifying a source location or macro expansion, along with range
84 information, and (optionally) a pointer for use by gcc.
85
86 This key only has meaning in relation to a line_maps instance. Within
87 gcc there is a single line_maps instance: "line_table", declared in
88 gcc/input.h and defined in gcc/input.cc.
89
90 The values of the keys are intended to be internal to libcpp, but for
91 ease-of-understanding the implementation, they are currently assigned as
92 follows in the case of 32-bit location_t:
93
94 Actual | Value | Meaning
95 -----------+-------------------------------+-------------------------------
96 0x00000000 | UNKNOWN_LOCATION (gcc/input.h)| Unknown/invalid location.
97 -----------+-------------------------------+-------------------------------
98 0x00000001 | BUILTINS_LOCATION | The location for declarations
99 | (gcc/input.h) | in "<built-in>"
100 -----------+-------------------------------+-------------------------------
101 0x00000002 | RESERVED_LOCATION_COUNT | The first location to be
102 | (also | handed out, and the
103 | ordmap[0]->start_location) | first line in ordmap 0
104 -----------+-------------------------------+-------------------------------
105 | ordmap[1]->start_location | First line in ordmap 1
106 | ordmap[1]->start_location+32 | First column in that line
107 | (assuming range_bits == 5) |
108 | ordmap[1]->start_location+64 | 2nd column in that line
109 | ordmap[1]->start_location+4096| Second line in ordmap 1
110 | (assuming column_bits == 12)
111 |
112 | Subsequent lines are offset by (1 << column_bits),
113 | e.g. 4096 for 12 bits, with a column value of 0 representing
114 | "the whole line".
115 |
116 | Within a line, the low "range_bits" (typically 5) are used for
117 | storing short ranges, so that there's an offset of
118 | (1 << range_bits) between individual columns within a line,
119 | typically 32.
120 | The low range_bits store the offset of the end point from the
121 | start point, and the start point is found by masking away
122 | the range bits.
123 |
124 | For example:
125 | ordmap[1]->start_location+64 "2nd column in that line"
126 | above means a caret at that location, with a range
127 | starting and finishing at the same place (the range bits
128 | are 0), a range of length 1.
129 |
130 | By contrast:
131 | ordmap[1]->start_location+68
132 | has range bits 0x4, meaning a caret with a range starting at
133 | that location, but with endpoint 4 columns further on: a range
134 | of length 5.
135 |
136 | Ranges that have caret != start, or have an endpoint too
137 | far away to fit in range_bits are instead stored as ad-hoc
138 | locations. Hence for range_bits == 5 we can compactly store
139 | tokens of length <= 32 without needing to use the ad-hoc
140 | table.
141 |
142 | This packing scheme means we effectively have
143 | (column_bits - range_bits)
144 | of bits for the columns, typically (12 - 5) = 7, for 128
145 | columns; longer line widths are accomodated by starting a
146 | new ordmap with a higher column_bits.
147 |
148 | ordmap[2]->start_location-1 | Final location in ordmap 1
149 -----------+-------------------------------+-------------------------------
150 | ordmap[2]->start_location | First line in ordmap 2
151 | ordmap[3]->start_location-1 | Final location in ordmap 2
152 -----------+-------------------------------+-------------------------------
153 | | (etc)
154 -----------+-------------------------------+-------------------------------
155 | ordmap[n-1]->start_location | First line in final ord map
156 | | (etc)
157 | set->highest_location - 1 | Final location in that ordmap
158 -----------+-------------------------------+-------------------------------
159 | set->highest_location | Location of the where the next
160 | | ordinary linemap would start
161 -----------+-------------------------------+-------------------------------
162 | |
163 | VVVVVVVVVVVVVVVVVVVVVVVVVVV
164 | Ordinary maps grow this way
165 |
166 | (unallocated integers)
167 |
168 0x60000000 | LINE_MAP_MAX_LOCATION_WITH_COLS
169 | Beyond this point, ordinary linemaps have 0 bits per column:
170 | each increment of the value corresponds to a new source line.
171 |
172 0x70000000 | LINE_MAP_MAX_LOCATION
173 | Beyond the point, we give up on ordinary maps; attempts to
174 | create locations in them lead to UNKNOWN_LOCATION (0).
175 |
176 | (unallocated integers)
177 |
178 | Macro maps grow this way
179 | ^^^^^^^^^^^^^^^^^^^^^^^^
180 | |
181 -----------+-------------------------------+-------------------------------
182 | LINEMAPS_MACRO_LOWEST_LOCATION| Locations within macro maps
183 | macromap[m-1]->start_location | Start of last macro map
184 | |
185 -----------+-------------------------------+-------------------------------
186 | macromap[m-2]->start_location | Start of penultimate macro map
187 -----------+-------------------------------+-------------------------------
188 | macromap[1]->start_location | Start of macro map 1
189 -----------+-------------------------------+-------------------------------
190 | macromap[0]->start_location | Start of macro map 0
191 0x7fffffff | MAX_LOCATION_T | Also used as a mask for
192 | | accessing the ad-hoc data table
193 -----------+-------------------------------+-------------------------------
194 0x80000000 | Start of ad-hoc values; the lower 31 bits are used as an index
195 ... | into the line_table->location_adhoc_data_map.data array.
196 0xffffffff | UINT_MAX |
197 -----------+-------------------------------+-------------------------------
198
199 Examples of location encoding.
200
201 Packed ranges
202 =============
203
204 Consider encoding the location of a token "foo", seen underlined here
205 on line 523, within an ordinary line_map that starts at line 500:
206
207 11111111112
208 12345678901234567890
209 522
210 523 return foo + bar;
211 ^~~
212 524
213
214 The location's caret and start are both at line 523, column 11; the
215 location's finish is on the same line, at column 13 (an offset of 2
216 columns, for length 3).
217
218 Line 523 is offset 23 from the starting line of the ordinary line_map.
219
220 caret == start, and the offset of the finish fits within 5 bits, so
221 this can be stored as a packed range.
222
223 This is encoded as:
224 ordmap->start
225 + (line_offset << ordmap->m_column_and_range_bits)
226 + (column << ordmap->m_range_bits)
227 + (range_offset);
228 i.e. (for line offset 23, column 11, range offset 2):
229 ordmap->start
230 + (23 << 12)
231 + (11 << 5)
232 + 2;
233 i.e.:
234 ordmap->start + 0x17162
235 assuming that the line_map uses the default of 7 bits for columns and
236 5 bits for packed range (giving 12 bits for m_column_and_range_bits).
237
238
239 "Pure" locations
240 ================
241
242 These are a special case of the above, where
243 caret == start == finish
244 They are stored as packed ranges with offset == 0.
245 For example, the location of the "f" of "foo" could be stored
246 as above, but with range offset 0, giving:
247 ordmap->start
248 + (23 << 12)
249 + (11 << 5)
250 + 0;
251 i.e.:
252 ordmap->start + 0x17160
253
254
255 Unoptimized ranges
256 ==================
257
258 Consider encoding the location of the binary expression
259 below:
260
261 11111111112
262 12345678901234567890
263 522
264 523 return foo + bar;
265 ~~~~^~~~~
266 524
267
268 The location's caret is at the "+", line 523 column 15, but starts
269 earlier, at the "f" of "foo" at column 11. The finish is at the "r"
270 of "bar" at column 19.
271
272 This can't be stored as a packed range since start != caret.
273 Hence it is stored as an ad-hoc location e.g. 0x80000003.
274
275 Stripping off the top bit gives us an index into the ad-hoc
276 lookaside table:
277
278 line_table->location_adhoc_data_map.data[0x3]
279
280 from which the caret, start and finish can be looked up,
281 encoded as "pure" locations:
282
283 start == ordmap->start + (23 << 12) + (11 << 5)
284 == ordmap->start + 0x17160 (as above; the "f" of "foo")
285
286 caret == ordmap->start + (23 << 12) + (15 << 5)
287 == ordmap->start + 0x171e0
288
289 finish == ordmap->start + (23 << 12) + (19 << 5)
290 == ordmap->start + 0x17260
291
292 To further see how location_t works in practice, see the
293 worked example in libcpp/location-example.txt. */
294
295/* A 64-bit type to represent a location. We only use 63 of the 64 bits, so
296 that two location_t can be safely subtracted and stored in an int64_t. */
297typedef uint64_t location_t;
298typedef int64_t location_diff_t;
299
300/* Sometimes we need a type that has the same size as location_t but that does
301 not represent a location. This typedef provides more clarity in those
302 cases. */
303typedef location_t line_map_uint_t;
304
305/* Do not track column numbers higher than this one. As a result, the
306 range of column_bits is [12, 18] (or 0 if column numbers are
307 disabled). */
308const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 31) - 1;
309
310/* Do not pack ranges if locations get higher than this.
311 If you change this, update:
312 gcc.dg/plugin/location-overflow-test-*.c. */
313const location_t LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
314 = location_t (0x50000000) << 31;
315
316/* Do not track column numbers if locations get higher than this.
317 If you change this, update:
318 gcc.dg/plugin/location-overflow-test-*.c. */
319const location_t LINE_MAP_MAX_LOCATION_WITH_COLS
320 = location_t (0x60000000) << 31;
321
322/* Highest possible source location encoded within an ordinary map. Higher
323 values up to MAX_LOCATION_T represent macro virtual locations. */
324const location_t LINE_MAP_MAX_LOCATION = location_t (0x70000000) << 31;
325
326/* This is the highest possible source location encoded within an
327 ordinary or macro map. */
328const location_t MAX_LOCATION_T = location_t (-1) >> 2;
329
330/* This is the number of range bits suggested to enable, if range tracking is
331 desired. */
332const int line_map_suggested_range_bits = 7;
333
334/* A range of source locations.
335
336 Ranges are closed:
337 m_start is the first location within the range,
338 m_finish is the last location within the range.
339
340 We may need a more compact way to store these, but for now,
341 let's do it the simple way, as a pair. */
342struct GTY(()) source_range
343{
344 location_t m_start;
345 location_t m_finish;
346
347 /* We avoid using constructors, since various structs that
348 don't yet have constructors will embed instances of
349 source_range. */
350
351 /* Make a source_range from a location_t. */
352 static source_range from_location (location_t loc)
353 {
354 source_range result;
355 result.m_start = loc;
356 result.m_finish = loc;
357 return result;
358 }
359
360 /* Make a source_range from a pair of location_t. */
361 static source_range from_locations (location_t start,
362 location_t finish)
363 {
364 source_range result;
365 result.m_start = start;
366 result.m_finish = finish;
367 return result;
368 }
369};
370
371/* Memory allocation function typedef. Works like xrealloc. */
372typedef void *(*line_map_realloc) (void *, size_t);
373
374/* Memory allocator function that returns the actual allocated size,
375 for a given requested allocation. */
376typedef size_t (*line_map_round_alloc_size_func) (size_t);
377
378/* A line_map encodes a sequence of locations.
379 There are two kinds of maps. Ordinary maps and macro expansion
380 maps, a.k.a macro maps.
381
382 A macro map encodes source locations of tokens that are part of a
383 macro replacement-list, at a macro expansion point. E.g, in:
384
385 #define PLUS(A,B) A + B
386
387 No macro map is going to be created there, because we are not at a
388 macro expansion point. We are at a macro /definition/ point. So the
389 locations of the tokens of the macro replacement-list (i.e, A + B)
390 will be locations in an ordinary map, not a macro map.
391
392 On the other hand, if we later do:
393
394 int a = PLUS (1,2);
395
396 The invocation of PLUS here is a macro expansion. So we are at a
397 macro expansion point. The preprocessor expands PLUS (1,2) and
398 replaces it with the tokens of its replacement-list: 1 + 2. A macro
399 map is going to be created to hold (or rather to map, haha ...) the
400 locations of the tokens 1, + and 2. The macro map also records the
401 location of the expansion point of PLUS. That location is mapped in
402 the map that is active right before the location of the invocation
403 of PLUS. */
404
405/* This contains GTY mark-up to support precompiled headers.
406 line_map is an abstract class, only derived objects exist. */
407struct GTY((tag ("0"), desc ("MAP_ORDINARY_P (&%h) ? 1 : 2"))) line_map {
408 location_t start_location;
409
410 /* Size is 8 bytes; alignment 4 or 8 depending on the arch. */
411};
412
413/* An ordinary line map encodes physical source locations. Those
414 physical source locations are called "spelling locations".
415
416 Physical source file TO_FILE at line TO_LINE at column 0 is represented
417 by the logical START_LOCATION. TO_LINE+L at column C is represented by
418 START_LOCATION+(L*(1<<m_column_and_range_bits))+(C*1<<m_range_bits), as
419 long as C<(1<<effective range bits), and the result_location is less than
420 the next line_map's start_location.
421 (The top line is line 1 and the leftmost column is column 1; line/column 0
422 means "entire file/line" or "unknown line/column" or "not applicable".)
423
424 The highest possible source location is MAX_LOCATION_T. */
425struct GTY((tag ("1"))) line_map_ordinary : public line_map {
426 /* Base class is 8 bytes. */
427
428 /* 4 bytes of integers, each 1 byte for easy extraction/insertion. */
429
430 /* The reason for creation of this line map. */
431 ENUM_BITFIELD (lc_reason) reason : 8;
432
433 /* SYSP is one for a system header, two for a C system header file
434 that therefore needs to be extern "C" protected in C++, and zero
435 otherwise. This field isn't really needed now that it's in
436 cpp_buffer. */
437 unsigned char sysp;
438
439 /* Number of the low-order location_t bits used for column numbers
440 and ranges. */
441 unsigned int m_column_and_range_bits : 8;
442
443 /* Number of the low-order "column" bits used for storing short ranges
444 inline, rather than in the ad-hoc table.
445 MSB LSB
446 31 0
447 +-------------------------+-------------------------------------------+
448 | |<---map->column_and_range_bits (e.g. 12)-->|
449 +-------------------------+-----------------------+-------------------+
450 | | column_and_range_bits | map->range_bits |
451 | | - range_bits | |
452 +-------------------------+-----------------------+-------------------+
453 | row bits | effective column bits | short range bits |
454 | | (e.g. 7) | (e.g. 5) |
455 +-------------------------+-----------------------+-------------------+ */
456 unsigned int m_range_bits : 8;
457
458 /* 32-bit int even in 64-bit mode. */
459 linenum_type to_line;
460
461 /* Location from whence this line map was included. For regular
462 #includes, this location will be the last location of a map. For
463 outermost file, this is 0. For modules it could be anywhere
464 within a map. */
465 location_t included_from;
466
467 /* Pointer alignment boundary, whether 32-bit or 64-bit mode. */
468 const char *to_file;
469
470 /* Size is 28 (32) bytes for 32-bit (64-bit) arch. */
471};
472
473struct cpp_hashnode;
474
475/* A macro line map encodes location of tokens coming from a macro
476 expansion.
477
478 The offset from START_LOCATION is used to index into
479 MACRO_LOCATIONS; this holds the original location of the token. */
480struct GTY((tag ("2"))) line_map_macro : public line_map {
481
482 /* Get the location of the expansion point of this macro map. */
483
484 location_t
485 get_expansion_point_location () const
486 {
487 return m_expansion;
488 }
489
490 /* Base is 8 bytes. */
491
492 /* The number of tokens inside the replacement-list of MACRO. */
493 unsigned int n_tokens;
494
495 /* Pointer alignment boundary. */
496
497 /* The cpp macro whose expansion gave birth to this macro map. */
498 struct cpp_hashnode *
499 GTY ((nested_ptr (union tree_node,
500 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
501 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
502 macro;
503
504 /* This array of location is actually an array of pairs of
505 locations. The elements inside it thus look like:
506
507 x0,y0, x1,y1, x2,y2, ...., xn,yn.
508
509 where n == n_tokens;
510
511 Remember that these xI,yI are collected when libcpp is about to
512 expand a given macro.
513
514 yI is the location in the macro definition, either of the token
515 itself or of a macro parameter that it replaces.
516
517 Imagine this:
518
519 #define PLUS(A, B) A + B <--- #1
520
521 int a = PLUS (1,2); <--- #2
522
523 There is a macro map for the expansion of PLUS in #2. PLUS is
524 expanded into its expansion-list. The expansion-list is the
525 replacement-list of PLUS where the macro parameters are replaced
526 with their arguments. So the replacement-list of PLUS is made of
527 the tokens:
528
529 A, +, B
530
531 and the expansion-list is made of the tokens:
532
533 1, +, 2
534
535 Let's consider the case of token "+". Its y1 [yI for I == 1] is
536 its spelling location in #1.
537
538 y0 (thus for token "1") is the spelling location of A in #1.
539
540 And y2 (of token "2") is the spelling location of B in #1.
541
542 When the token is /not/ an argument for a macro, xI is the same
543 location as yI. Otherwise, xI is the location of the token
544 outside this macro expansion. If this macro was expanded from
545 another macro expansion, xI is a virtual location representing
546 the token in that macro expansion; otherwise, it is the spelling
547 location of the token.
548
549 Note that a virtual location is a location returned by
550 linemap_add_macro_token. It encodes the relevant locations (x,y
551 pairs) of that token across the macro expansions from which it
552 (the token) might come from.
553
554 In the example above x1 (for token "+") is going to be the same
555 as y1. x0 is the spelling location for the argument token "1",
556 and x2 is the spelling location for the argument token "2". */
557 location_t * GTY((atomic)) macro_locations;
558
559 /* This is the location of the expansion point of the current macro
560 map. It's the location of the macro name. That location is held
561 by the map that was current right before the current one. It
562 could have been either a macro or an ordinary map, depending on
563 if we are in a nested expansion context not. */
564 location_t m_expansion;
565
566 /* Size is one of the following:
567 32-bit system: 28 or 32 bytes, depending whether a uint64_t requires
568 4- or 8-byte alignment.
569 64-bit arch: 40 bytes. */
570};
571
572#if CHECKING_P && (GCC_VERSION >= 2007)
573
574/* Assertion macro to be used in line-map code. */
575#define linemap_assert(EXPR) \
576 do { \
577 if (! (EXPR)) \
578 abort (); \
579 } while (0)
580
581/* Assert that becomes a conditional expression when checking is disabled at
582 compilation time. Use this for conditions that should not happen but if
583 they happen, it is better to handle them gracefully rather than crash
584 randomly later.
585 Usage:
586
587 if (linemap_assert_fails(EXPR)) handle_error(); */
588#define linemap_assert_fails(EXPR) __extension__ \
589 ({linemap_assert (EXPR); false;})
590
591#else
592/* Include EXPR, so that unused variable warnings do not occur. */
593#define linemap_assert(EXPR) ((void)(0 && (EXPR)))
594#define linemap_assert_fails(EXPR) (! (EXPR))
595#endif
596
597/* Get whether location LOC is an ordinary location. */
598
599inline bool
600IS_ORDINARY_LOC (location_t loc)
601{
602 return loc < LINE_MAP_MAX_LOCATION;
603}
604
605/* Get whether location LOC is an ad-hoc location. */
606
607inline bool
608IS_ADHOC_LOC (location_t loc)
609{
610 return loc > MAX_LOCATION_T;
611}
612
613/* Categorize line map kinds. */
614
615inline bool
616MAP_ORDINARY_P (const line_map *map)
617{
618 return IS_ORDINARY_LOC (loc: map->start_location);
619}
620
621/* Return TRUE if MAP encodes locations coming from a macro
622 replacement-list at macro expansion point. */
623bool
624linemap_macro_expansion_map_p (const line_map *);
625
626/* Assert that MAP encodes locations of tokens that are not part of
627 the replacement-list of a macro expansion, downcasting from
628 line_map * to line_map_ordinary *. */
629
630inline line_map_ordinary *
631linemap_check_ordinary (line_map *map)
632{
633 linemap_assert (MAP_ORDINARY_P (map));
634 return (line_map_ordinary *)map;
635}
636
637/* Assert that MAP encodes locations of tokens that are not part of
638 the replacement-list of a macro expansion, downcasting from
639 const line_map * to const line_map_ordinary *. */
640
641inline const line_map_ordinary *
642linemap_check_ordinary (const line_map *map)
643{
644 linemap_assert (MAP_ORDINARY_P (map));
645 return (const line_map_ordinary *)map;
646}
647
648/* Assert that MAP is a macro expansion and downcast to the appropriate
649 subclass. */
650
651inline line_map_macro *linemap_check_macro (line_map *map)
652{
653 linemap_assert (!MAP_ORDINARY_P (map));
654 return (line_map_macro *)map;
655}
656
657/* Assert that MAP is a macro expansion and downcast to the appropriate
658 subclass. */
659
660inline const line_map_macro *
661linemap_check_macro (const line_map *map)
662{
663 linemap_assert (!MAP_ORDINARY_P (map));
664 return (const line_map_macro *)map;
665}
666
667/* Read the start location of MAP. */
668
669inline location_t
670MAP_START_LOCATION (const line_map *map)
671{
672 return map->start_location;
673}
674
675/* Get the starting line number of ordinary map MAP. */
676
677inline linenum_type
678ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map)
679{
680 return ord_map->to_line;
681}
682
683/* Return a positive value if map encodes locations from a system
684 header, 0 otherwise. Returns 1 if ordinary map MAP encodes locations
685 in a system header and 2 if it encodes locations in a C system header
686 that therefore needs to be extern "C" protected in C++. */
687
688inline unsigned char
689ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map)
690{
691 return ord_map->sysp;
692}
693
694/* TRUE if this line map is for a module (not a source file). */
695
696inline bool
697MAP_MODULE_P (const line_map *map)
698{
699 return (MAP_ORDINARY_P (map)
700 && linemap_check_ordinary (map)->reason == LC_MODULE);
701}
702
703/* Get the filename of ordinary map MAP. */
704
705inline const char *
706ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map)
707{
708 return ord_map->to_file;
709}
710
711/* Get the cpp macro whose expansion gave birth to macro map MAP. */
712
713inline cpp_hashnode *
714MACRO_MAP_MACRO (const line_map_macro *macro_map)
715{
716 return macro_map->macro;
717}
718
719/* Get the number of tokens inside the replacement-list of the macro
720 that led to macro map MAP. */
721
722inline unsigned int
723MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map)
724{
725 return macro_map->n_tokens;
726}
727
728/* Get the array of pairs of locations within macro map MAP.
729 See the declaration of line_map_macro for more information. */
730
731inline location_t *
732MACRO_MAP_LOCATIONS (const line_map_macro *macro_map)
733{
734 return macro_map->macro_locations;
735}
736
737/* The abstraction of a set of location maps. There can be several
738 types of location maps. This abstraction contains the attributes
739 that are independent from the type of the map.
740
741 Essentially this is just a vector of T_linemap_subclass,
742 which can only ever grow in size. */
743
744struct GTY(()) maps_info_ordinary {
745 /* This array contains the "ordinary" line maps, for all
746 events other than macro expansion
747 (e.g. when a new preprocessing unit starts or ends). */
748 line_map_ordinary * GTY ((length ("%h.used"))) maps;
749
750 /* The total number of allocated maps. */
751 line_map_uint_t allocated;
752
753 /* The number of elements used in maps. This number is smaller
754 or equal to ALLOCATED. */
755 line_map_uint_t used;
756
757 /* The index of the last ordinary map that was looked up with
758 linemap_lookup. */
759 mutable line_map_uint_t m_cache;
760};
761
762struct GTY(()) maps_info_macro {
763 /* This array contains the macro line maps.
764 A macro line map is created whenever a macro expansion occurs. */
765 line_map_macro * GTY ((length ("%h.used"))) maps;
766
767 /* The total number of allocated maps. */
768 line_map_uint_t allocated;
769
770 /* The number of elements used in maps. This number is smaller
771 or equal to ALLOCATED. */
772 line_map_uint_t used;
773
774 /* The index of the last macro map that was looked up with
775 linemap_lookup. */
776 mutable line_map_uint_t m_cache;
777};
778
779/* Data structure to associate a source_range together with an arbitrary
780 data pointer with a source location. */
781struct GTY(()) location_adhoc_data {
782 location_t locus;
783 source_range src_range;
784 void * GTY((skip)) data;
785 unsigned discriminator;
786};
787
788struct htab;
789
790/* The following data structure encodes a location with some adhoc data
791 and maps it to a new unsigned integer (called an adhoc location)
792 that replaces the original location to represent the mapping.
793
794 The new adhoc_loc uses the highest bit as the enabling bit, i.e. if the
795 highest bit is 1, then the number is adhoc_loc. Otherwise, it serves as
796 the original location. Once identified as the adhoc_loc, the lower 62
797 bits of the integer is used to index the location_adhoc_data array,
798 in which the locus and associated data is stored. */
799
800struct GTY(()) location_adhoc_data_map {
801 struct htab * GTY((skip)) htab;
802 location_t curr_loc;
803 line_map_uint_t allocated;
804 struct location_adhoc_data GTY((length ("%h.allocated"))) *data;
805};
806
807/* A set of chronological line_map structures. */
808class GTY(()) line_maps {
809public:
810
811 ~line_maps ();
812
813 bool pure_location_p (location_t loc) const;
814 location_t get_pure_location (location_t loc) const;
815
816 source_range get_range_from_loc (location_t loc) const;
817 location_t get_start (location_t loc) const
818 {
819 return get_range_from_loc (loc).m_start;
820 }
821 location_t
822 get_finish (location_t loc) const
823 {
824 return get_range_from_loc (loc).m_finish;
825 }
826
827 location_t make_location (location_t caret,
828 location_t start,
829 location_t finish);
830
831 location_t
832 get_or_create_combined_loc (location_t locus,
833 source_range src_range,
834 void *data,
835 unsigned discriminator);
836
837 private:
838 bool can_be_stored_compactly_p (location_t locus,
839 source_range src_range,
840 void *data,
841 unsigned discriminator) const;
842 source_range get_range_from_adhoc_loc (location_t loc) const;
843
844 public:
845 maps_info_ordinary info_ordinary;
846
847 maps_info_macro info_macro;
848
849 /* Depth of the include stack, including the current file. */
850 unsigned int depth;
851
852 /* If true, prints an include trace a la -H. */
853 bool trace_includes;
854
855 /* True if we've seen a #line or # 44 "file" directive. */
856 bool seen_line_directive;
857
858 /* Highest location_t "given out". */
859 location_t highest_location;
860
861 /* Start of line of highest location_t "given out". */
862 location_t highest_line;
863
864 /* The maximum column number we can quickly allocate. Higher numbers
865 may require allocating a new line_map. */
866 unsigned int max_column_hint;
867
868 /* The allocator to use when resizing 'maps', defaults to xrealloc. */
869 line_map_realloc GTY((callback)) m_reallocator;
870
871 /* The allocators' function used to know the actual size it
872 allocated, for a certain allocation size requested. */
873 line_map_round_alloc_size_func GTY((callback)) m_round_alloc_size;
874
875 struct location_adhoc_data_map m_location_adhoc_data_map;
876
877 /* The special location value that is used as spelling location for
878 built-in tokens. */
879 location_t builtin_location;
880
881 /* The special location value to be used for tokens originating on the
882 command line. This is currently only needed by the C-family front ends
883 for PCH support; if it would be used for another purpose in the future,
884 then other libcpp-using front ends may need to set it as well. */
885 location_t cmdline_location;
886
887 /* The default value of range_bits in ordinary line maps. */
888 unsigned int default_range_bits;
889
890 line_map_uint_t m_num_optimized_ranges;
891 line_map_uint_t m_num_unoptimized_ranges;
892};
893
894/* Returns the number of allocated maps so far. MAP_KIND shall be TRUE
895 if we are interested in macro maps, FALSE otherwise. */
896inline line_map_uint_t
897LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind)
898{
899 if (map_kind)
900 return set->info_macro.allocated;
901 else
902 return set->info_ordinary.allocated;
903}
904
905/* As above, but by reference (e.g. as an lvalue). */
906
907inline line_map_uint_t &
908LINEMAPS_ALLOCATED (line_maps *set, bool map_kind)
909{
910 if (map_kind)
911 return set->info_macro.allocated;
912 else
913 return set->info_ordinary.allocated;
914}
915
916/* Returns the number of used maps so far. MAP_KIND shall be TRUE if
917 we are interested in macro maps, FALSE otherwise.*/
918inline line_map_uint_t
919LINEMAPS_USED (const line_maps *set, bool map_kind)
920{
921 if (map_kind)
922 return set->info_macro.used;
923 else
924 return set->info_ordinary.used;
925}
926
927/* As above, but by reference (e.g. as an lvalue). */
928
929inline line_map_uint_t &
930LINEMAPS_USED (line_maps *set, bool map_kind)
931{
932 if (map_kind)
933 return set->info_macro.used;
934 else
935 return set->info_ordinary.used;
936}
937
938/* Return the map at a given index. */
939inline line_map *
940LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, line_map_uint_t index)
941{
942 if (map_kind)
943 return &set->info_macro.maps[index];
944 else
945 return &set->info_ordinary.maps[index];
946}
947
948/* Returns the last map used in the line table SET. MAP_KIND
949 shall be TRUE if we are interested in macro maps, FALSE
950 otherwise.*/
951inline line_map *
952LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind)
953{
954 linemap_assert (LINEMAPS_USED (set, map_kind));
955 return LINEMAPS_MAP_AT (set, map_kind,
956 index: LINEMAPS_USED (set, map_kind) - 1);
957}
958
959/* Returns the INDEXth ordinary map. */
960inline line_map_ordinary *
961LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, line_map_uint_t index)
962{
963 linemap_assert (index < LINEMAPS_USED (set, false));
964 return (line_map_ordinary *)LINEMAPS_MAP_AT (set, map_kind: false, index);
965}
966
967/* Return the number of ordinary maps allocated in the line table
968 SET. */
969inline line_map_uint_t
970LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set)
971{
972 return LINEMAPS_ALLOCATED (set, map_kind: false);
973}
974
975/* Return the number of ordinary maps used in the line table SET. */
976inline line_map_uint_t
977LINEMAPS_ORDINARY_USED (const line_maps *set)
978{
979 return LINEMAPS_USED (set, map_kind: false);
980}
981
982/* Returns a pointer to the last ordinary map used in the line table
983 SET. */
984inline line_map_ordinary *
985LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set)
986{
987 return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, map_kind: false);
988}
989
990/* Returns the INDEXth macro map. */
991inline line_map_macro *
992LINEMAPS_MACRO_MAP_AT (const line_maps *set, line_map_uint_t index)
993{
994 linemap_assert (index < LINEMAPS_USED (set, true));
995 return (line_map_macro *)LINEMAPS_MAP_AT (set, map_kind: true, index);
996}
997
998/* Returns the number of macro maps that were allocated in the line
999 table SET. */
1000inline line_map_uint_t
1001LINEMAPS_MACRO_ALLOCATED (const line_maps *set)
1002{
1003 return LINEMAPS_ALLOCATED (set, map_kind: true);
1004}
1005
1006/* Returns the number of macro maps used in the line table SET. */
1007inline line_map_uint_t
1008LINEMAPS_MACRO_USED (const line_maps *set)
1009{
1010 return LINEMAPS_USED (set, map_kind: true);
1011}
1012
1013/* Returns the last macro map used in the line table SET. */
1014inline line_map_macro *
1015LINEMAPS_LAST_MACRO_MAP (const line_maps *set)
1016{
1017 return (line_map_macro *)LINEMAPS_LAST_MAP (set, map_kind: true);
1018}
1019
1020/* Returns the lowest location [of a token resulting from macro
1021 expansion] encoded in this line table. */
1022inline location_t
1023LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set)
1024{
1025 return LINEMAPS_MACRO_USED (set)
1026 ? MAP_START_LOCATION (map: LINEMAPS_LAST_MACRO_MAP (set))
1027 : MAX_LOCATION_T + 1;
1028}
1029
1030extern void *get_data_from_adhoc_loc (const line_maps *, location_t);
1031extern unsigned get_discriminator_from_adhoc_loc (const line_maps *, location_t);
1032extern location_t get_location_from_adhoc_loc (const line_maps *,
1033 location_t);
1034
1035extern source_range get_range_from_loc (const line_maps *set, location_t loc);
1036extern unsigned get_discriminator_from_loc (const line_maps *set, location_t loc);
1037
1038/* Get whether location LOC is a "pure" location, or
1039 whether it is an ad-hoc location, or embeds range information. */
1040
1041bool
1042pure_location_p (const line_maps *set, location_t loc);
1043
1044/* Given location LOC within SET, strip away any packed range information
1045 or ad-hoc information. */
1046
1047extern location_t get_pure_location (const line_maps *set, location_t loc);
1048
1049extern void rebuild_location_adhoc_htab (class line_maps *);
1050
1051/* Initialize a line map set. SET is the line map set to initialize
1052 and BUILTIN_LOCATION is the special location value to be used as
1053 spelling location for built-in tokens. This BUILTIN_LOCATION has
1054 to be strictly less than RESERVED_LOCATION_COUNT. */
1055extern void linemap_init (class line_maps *set,
1056 location_t builtin_location);
1057
1058/* Check for and warn about line_maps entered but not exited. */
1059
1060extern void linemap_check_files_exited (const line_maps *);
1061
1062/* Return a location_t for the start (i.e. column==0) of
1063 (physical) line TO_LINE in the current source file (as in the
1064 most recent linemap_add). MAX_COLUMN_HINT is the highest column
1065 number we expect to use in this line (but it does not change
1066 the highest_location). */
1067
1068extern location_t linemap_line_start
1069(class line_maps *set, linenum_type to_line, unsigned int max_column_hint);
1070
1071/* Allocate a raw block of line maps, zero initialized. */
1072extern line_map *line_map_new_raw (line_maps *, bool, line_map_uint_t);
1073
1074/* Add a mapping of logical source line to physical source file and
1075 line number. This function creates an "ordinary map", which is a
1076 map that records locations of tokens that are not part of macro
1077 replacement-lists present at a macro expansion point.
1078
1079 The text pointed to by TO_FILE must have a lifetime
1080 at least as long as the lifetime of SET. An empty
1081 TO_FILE means standard input. If reason is LC_LEAVE, and
1082 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
1083 natural values considering the file we are returning to.
1084
1085 A call to this function can relocate the previous set of
1086 maps, so any stored line_map pointers should not be used. */
1087extern const line_map *linemap_add
1088 (class line_maps *, enum lc_reason, unsigned int sysp,
1089 const char *to_file, linenum_type to_line);
1090
1091/* Create a macro map. A macro map encodes source locations of tokens
1092 that are part of a macro replacement-list, at a macro expansion
1093 point. See the extensive comments of struct line_map and struct
1094 line_map_macro, in line-map.h.
1095
1096 This map shall be created when the macro is expanded. The map
1097 encodes the source location of the expansion point of the macro as
1098 well as the "original" source location of each token that is part
1099 of the macro replacement-list. If a macro is defined but never
1100 expanded, it has no macro map. SET is the set of maps the macro
1101 map should be part of. MACRO_NODE is the macro which the new macro
1102 map should encode source locations for. EXPANSION is the location
1103 of the expansion point of MACRO. For function-like macros
1104 invocations, it's best to make it point to the closing parenthesis
1105 of the macro, rather than the the location of the first character
1106 of the macro. NUM_TOKENS is the number of tokens that are part of
1107 the replacement-list of MACRO. */
1108const line_map_macro *linemap_enter_macro (line_maps *, cpp_hashnode *,
1109 location_t, unsigned int);
1110
1111/* Create a source location for a module. The creator must either do
1112 this after the TU is tokenized, or deal with saving and restoring
1113 map state. */
1114
1115extern location_t linemap_module_loc
1116 (line_maps *, location_t from, const char *name);
1117extern void linemap_module_reparent
1118 (line_maps *, location_t loc, location_t new_parent);
1119
1120/* TRUE iff the location comes from a module import. */
1121extern bool linemap_location_from_module_p
1122 (const line_maps *, location_t);
1123
1124/* Restore the linemap state such that the map at LWM-1 continues.
1125 Return start location of the new map. */
1126extern location_t linemap_module_restore
1127 (line_maps *, line_map_uint_t lwm);
1128
1129/* Given a logical source location, returns the map which the
1130 corresponding (source file, line, column) triplet can be deduced
1131 from. Since the set is built chronologically, the logical lines are
1132 monotonic increasing, and so the list is sorted and we can use a
1133 binary search. If no line map have been allocated yet, this
1134 function returns NULL. */
1135extern const line_map *linemap_lookup
1136 (const line_maps *, location_t);
1137
1138line_map_uint_t linemap_lookup_macro_index (const line_maps *, location_t);
1139
1140/* Returns TRUE if the line table set tracks token locations across
1141 macro expansion, FALSE otherwise. */
1142bool linemap_tracks_macro_expansion_locs_p (const line_maps *);
1143
1144/* Return the name of the macro associated to MACRO_MAP. */
1145const char* linemap_map_get_macro_name (const line_map_macro *);
1146
1147/* Return a positive value if LOCATION is the locus of a token that is
1148 located in a system header, O otherwise. It returns 1 if LOCATION
1149 is the locus of a token that is located in a system header, and 2
1150 if LOCATION is the locus of a token located in a C system header
1151 that therefore needs to be extern "C" protected in C++.
1152
1153 Note that this function returns 1 if LOCATION belongs to a token
1154 that is part of a macro replacement-list defined in a system
1155 header, but expanded in a non-system file. */
1156int linemap_location_in_system_header_p (const line_maps *,
1157 location_t);
1158
1159/* Return TRUE if LOCATION is a source code location of a token that is part of
1160 a macro expansion, FALSE otherwise. */
1161bool linemap_location_from_macro_expansion_p (const line_maps *,
1162 location_t);
1163
1164/* TRUE if LOCATION is a source code location of a token that is part of the
1165 definition of a macro, FALSE otherwise. */
1166bool linemap_location_from_macro_definition_p (const line_maps *,
1167 location_t);
1168
1169/* With the precondition that LOCATION is the locus of a token that is
1170 an argument of a function-like macro MACRO_MAP and appears in the
1171 expansion of MACRO_MAP, return the locus of that argument in the
1172 context of the caller of MACRO_MAP. */
1173
1174extern location_t
1175linemap_macro_map_loc_unwind_toward_spelling (const line_maps *set,
1176 const line_map_macro *macro_map,
1177 location_t location);
1178
1179/* location_t values from 0 to RESERVED_LOCATION_COUNT-1 will
1180 be reserved for libcpp user as special values, no token from libcpp
1181 will contain any of those locations. */
1182const location_t RESERVED_LOCATION_COUNT = 2;
1183
1184/* Converts a map and a location_t to source line. */
1185inline linenum_type
1186SOURCE_LINE (const line_map_ordinary *ord_map, location_t loc)
1187{
1188 return ((loc - ord_map->start_location)
1189 >> ord_map->m_column_and_range_bits) + ord_map->to_line;
1190}
1191
1192/* Convert a map and location_t to source column number. */
1193inline linenum_type
1194SOURCE_COLUMN (const line_map_ordinary *ord_map, location_t loc)
1195{
1196 return ((loc - ord_map->start_location)
1197 & ((location_t (1) << ord_map->m_column_and_range_bits) - 1))
1198 >> ord_map->m_range_bits;
1199}
1200
1201
1202inline location_t
1203linemap_included_from (const line_map_ordinary *ord_map)
1204{
1205 return ord_map->included_from;
1206}
1207
1208/* The linemap containing the included-from location of MAP. */
1209const line_map_ordinary *
1210linemap_included_from_linemap (const line_maps *set,
1211 const line_map_ordinary *map);
1212
1213/* True if the map is at the bottom of the include stack. */
1214
1215inline bool
1216MAIN_FILE_P (const line_map_ordinary *ord_map)
1217{
1218 return ord_map->included_from == 0;
1219}
1220
1221/* Encode and return a location_t from a column number. The
1222 source line considered is the last source line used to call
1223 linemap_line_start, i.e, the last source line which a location was
1224 encoded from. */
1225extern location_t
1226linemap_position_for_column (class line_maps *, unsigned int);
1227
1228/* Encode and return a source location from a given line and
1229 column. */
1230location_t
1231linemap_position_for_line_and_column (line_maps *set,
1232 const line_map_ordinary *,
1233 linenum_type, unsigned int);
1234
1235/* Encode and return a location_t starting from location LOC and
1236 shifting it by OFFSET columns. This function does not support
1237 virtual locations. */
1238location_t
1239linemap_position_for_loc_and_offset (class line_maps *set,
1240 location_t loc,
1241 unsigned int offset);
1242
1243/* Return the file this map is for. */
1244inline const char *
1245LINEMAP_FILE (const line_map_ordinary *ord_map)
1246{
1247 return ord_map->to_file;
1248}
1249
1250/* Return the line number this map started encoding location from. */
1251inline linenum_type
1252LINEMAP_LINE (const line_map_ordinary *ord_map)
1253{
1254 return ord_map->to_line;
1255}
1256
1257/* Return a positive value if map encodes locations from a system
1258 header, 0 otherwise. Returns 1 if MAP encodes locations in a
1259 system header and 2 if it encodes locations in a C system header
1260 that therefore needs to be extern "C" protected in C++. */
1261inline unsigned char
1262LINEMAP_SYSP (const line_map_ordinary *ord_map)
1263{
1264 return ord_map->sysp;
1265}
1266
1267const struct line_map *first_map_in_common (const line_maps *set,
1268 location_t loc0,
1269 location_t loc1,
1270 location_t *res_loc0,
1271 location_t *res_loc1);
1272
1273/* Return a positive value if PRE denotes the location of a token that
1274 comes before the token of POST, 0 if PRE denotes the location of
1275 the same token as the token for POST, and a negative value
1276 otherwise. */
1277int
1278linemap_compare_locations (const line_maps *set,
1279 location_t pre,
1280 location_t post);
1281
1282/* Return TRUE if LOC_A denotes the location a token that comes
1283 topogically before the token denoted by location LOC_B, or if they
1284 are equal. */
1285inline bool
1286linemap_location_before_p (const line_maps *set,
1287 location_t loc_a,
1288 location_t loc_b)
1289{
1290 return linemap_compare_locations (set, pre: loc_a, post: loc_b) >= 0;
1291}
1292
1293struct expanded_location
1294{
1295 /* The name of the source file involved. */
1296 const char *file;
1297
1298 /* The line-location in the source file. */
1299 int line;
1300
1301 int column;
1302
1303 void *data;
1304
1305 /* In a system header?. */
1306 bool sysp;
1307};
1308
1309extern bool
1310operator== (const expanded_location &a,
1311 const expanded_location &b);
1312inline bool
1313operator!= (const expanded_location &a,
1314 const expanded_location &b)
1315{
1316 return !(a == b);
1317}
1318
1319
1320/* This is enum is used by the function linemap_resolve_location
1321 below. The meaning of the values is explained in the comment of
1322 that function. */
1323enum location_resolution_kind
1324{
1325 LRK_MACRO_EXPANSION_POINT,
1326 LRK_SPELLING_LOCATION,
1327 LRK_MACRO_DEFINITION_LOCATION
1328};
1329
1330/* Resolve a virtual location into either a spelling location, an
1331 expansion point location or a token argument replacement point
1332 location. Return the map that encodes the virtual location as well
1333 as the resolved location.
1334
1335 If LOC is *NOT* the location of a token resulting from the
1336 expansion of a macro, then the parameter LRK (which stands for
1337 Location Resolution Kind) is ignored and the resulting location
1338 just equals the one given in argument.
1339
1340 Now if LOC *IS* the location of a token resulting from the
1341 expansion of a macro, this is what happens.
1342
1343 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1344 -------------------------------
1345
1346 The virtual location is resolved to the first macro expansion point
1347 that led to this macro expansion.
1348
1349 * If LRK is set to LRK_SPELLING_LOCATION
1350 -------------------------------------
1351
1352 The virtual location is resolved to the locus where the token has
1353 been spelled in the source. This can follow through all the macro
1354 expansions that led to the token.
1355
1356 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1357 --------------------------------------
1358
1359 The virtual location is resolved to the locus of the token in the
1360 context of the macro definition.
1361
1362 If LOC is the locus of a token that is an argument of a
1363 function-like macro [replacing a parameter in the replacement list
1364 of the macro] the virtual location is resolved to the locus of the
1365 parameter that is replaced, in the context of the definition of the
1366 macro.
1367
1368 If LOC is the locus of a token that is not an argument of a
1369 function-like macro, then the function behaves as if LRK was set to
1370 LRK_SPELLING_LOCATION.
1371
1372 If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the
1373 returned location. Note that if the returned location wasn't originally
1374 encoded by a map, the *MAP is set to NULL. This can happen if LOC
1375 resolves to a location reserved for the client code, like
1376 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1377
1378location_t linemap_resolve_location (const line_maps *,
1379 location_t loc,
1380 enum location_resolution_kind lrk,
1381 const line_map_ordinary **loc_map);
1382
1383/* Suppose that LOC is the virtual location of a token coming from the
1384 expansion of a macro M. This function then steps up to get the
1385 location L of the point where M got expanded. If L is a spelling
1386 location inside a macro expansion M', then this function returns
1387 the point where M' was expanded. LOC_MAP is an output parameter.
1388 When non-NULL, *LOC_MAP is set to the map of the returned
1389 location. */
1390location_t linemap_unwind_toward_expansion (const line_maps *,
1391 location_t loc,
1392 const line_map **loc_map);
1393
1394/* If LOC is the virtual location of a token coming from the expansion
1395 of a macro M and if its spelling location is reserved (e.g, a
1396 location for a built-in token), then this function unwinds (using
1397 linemap_unwind_toward_expansion) the location until a location that
1398 is not reserved and is not in a system header is reached. In other
1399 words, this unwinds the reserved location until a location that is
1400 in real source code is reached.
1401
1402 Otherwise, if the spelling location for LOC is not reserved or if
1403 LOC doesn't come from the expansion of a macro, the function
1404 returns LOC as is and *MAP is not touched.
1405
1406 *MAP is set to the map of the returned location if the later is
1407 different from LOC. */
1408location_t linemap_unwind_to_first_non_reserved_loc (const line_maps *,
1409 location_t loc,
1410 const line_map **map);
1411
1412/* Expand source code location LOC and return a user readable source
1413 code location. LOC must be a spelling (non-virtual) location. If
1414 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1415 location is returned. */
1416expanded_location linemap_expand_location (const line_maps *,
1417 const line_map *,
1418 location_t loc);
1419
1420/* Statistics about maps allocation and usage as returned by
1421 linemap_get_statistics. */
1422struct linemap_stats
1423{
1424 long num_ordinary_maps_allocated;
1425 long num_ordinary_maps_used;
1426 long ordinary_maps_allocated_size;
1427 long ordinary_maps_used_size;
1428 long num_expanded_macros;
1429 long num_macro_tokens;
1430 long num_macro_maps_used;
1431 long macro_maps_allocated_size;
1432 long macro_maps_used_size;
1433 long macro_maps_locations_size;
1434 long duplicated_macro_maps_locations_size;
1435 long adhoc_table_size;
1436 long adhoc_table_entries_used;
1437};
1438
1439/* Return the highest location emitted for a given file for which
1440 there is a line map in SET. FILE_NAME is the file name to
1441 consider. If the function returns TRUE, *LOC is set to the highest
1442 location emitted for that file. */
1443bool linemap_get_file_highest_location (const line_maps * set,
1444 const char *file_name,
1445 location_t *loc);
1446
1447/* Compute and return statistics about the memory consumption of some
1448 parts of the line table SET. */
1449void linemap_get_statistics (const line_maps *, struct linemap_stats *);
1450
1451/* Dump debugging information about source location LOC into the file
1452 stream STREAM. SET is the line map set LOC comes from. */
1453void linemap_dump_location (const line_maps *, location_t, FILE *);
1454
1455/* Dump line map at index IX in line table SET to STREAM. If STREAM
1456 is NULL, use stderr. IS_MACRO is true if the caller wants to
1457 dump a macro map, false otherwise. */
1458void linemap_dump (FILE *, const line_maps *, line_map_uint_t, bool);
1459
1460/* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
1461 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
1462 specifies how many macro maps to dump. */
1463void line_table_dump (FILE *, const line_maps *,
1464 line_map_uint_t, line_map_uint_t);
1465
1466/* An enum for distinguishing the various parts within a location_t. */
1467
1468enum class location_aspect
1469{
1470 caret,
1471 start,
1472 finish
1473};
1474
1475/* The rich_location class requires a way to expand location_t instances.
1476 We would directly use expand_location_to_spelling_point, which is
1477 implemented in gcc/input.cc, but we also need to use it for rich_location
1478 within genmatch.cc.
1479 Hence we require client code of libcpp to implement the following
1480 symbol. */
1481extern expanded_location
1482linemap_client_expand_location_to_spelling_point (const line_maps *,
1483 location_t,
1484 enum location_aspect);
1485
1486#endif /* !LIBCPP_LINE_MAP_H */
1487

source code of libcpp/include/line-map.h