1/* Map (unsigned int) keys to (source file, line, column) triples.
2 Copyright (C) 2001-2024 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,
91 but for ease-of-understanding the implementation, they are currently
92 assigned as follows:
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. */
294typedef unsigned int location_t;
295
296/* Do not track column numbers higher than this one. As a result, the
297 range of column_bits is [12, 18] (or 0 if column numbers are
298 disabled). */
299const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12);
300
301/* Do not pack ranges if locations get higher than this.
302 If you change this, update:
303 gcc.dg/plugin/location-overflow-test-*.c. */
304const location_t LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000;
305
306/* Do not track column numbers if locations get higher than this.
307 If you change this, update:
308 gcc.dg/plugin/location-overflow-test-*.c. */
309const location_t LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000;
310
311/* Highest possible source location encoded within an ordinary map. */
312const location_t LINE_MAP_MAX_LOCATION = 0x70000000;
313
314/* A range of source locations.
315
316 Ranges are closed:
317 m_start is the first location within the range,
318 m_finish is the last location within the range.
319
320 We may need a more compact way to store these, but for now,
321 let's do it the simple way, as a pair. */
322struct GTY(()) source_range
323{
324 location_t m_start;
325 location_t m_finish;
326
327 /* We avoid using constructors, since various structs that
328 don't yet have constructors will embed instances of
329 source_range. */
330
331 /* Make a source_range from a location_t. */
332 static source_range from_location (location_t loc)
333 {
334 source_range result;
335 result.m_start = loc;
336 result.m_finish = loc;
337 return result;
338 }
339
340 /* Make a source_range from a pair of location_t. */
341 static source_range from_locations (location_t start,
342 location_t finish)
343 {
344 source_range result;
345 result.m_start = start;
346 result.m_finish = finish;
347 return result;
348 }
349};
350
351/* Memory allocation function typedef. Works like xrealloc. */
352typedef void *(*line_map_realloc) (void *, size_t);
353
354/* Memory allocator function that returns the actual allocated size,
355 for a given requested allocation. */
356typedef size_t (*line_map_round_alloc_size_func) (size_t);
357
358/* A line_map encodes a sequence of locations.
359 There are two kinds of maps. Ordinary maps and macro expansion
360 maps, a.k.a macro maps.
361
362 A macro map encodes source locations of tokens that are part of a
363 macro replacement-list, at a macro expansion point. E.g, in:
364
365 #define PLUS(A,B) A + B
366
367 No macro map is going to be created there, because we are not at a
368 macro expansion point. We are at a macro /definition/ point. So the
369 locations of the tokens of the macro replacement-list (i.e, A + B)
370 will be locations in an ordinary map, not a macro map.
371
372 On the other hand, if we later do:
373
374 int a = PLUS (1,2);
375
376 The invocation of PLUS here is a macro expansion. So we are at a
377 macro expansion point. The preprocessor expands PLUS (1,2) and
378 replaces it with the tokens of its replacement-list: 1 + 2. A macro
379 map is going to be created to hold (or rather to map, haha ...) the
380 locations of the tokens 1, + and 2. The macro map also records the
381 location of the expansion point of PLUS. That location is mapped in
382 the map that is active right before the location of the invocation
383 of PLUS. */
384
385/* This contains GTY mark-up to support precompiled headers.
386 line_map is an abstract class, only derived objects exist. */
387struct GTY((tag ("0"), desc ("MAP_ORDINARY_P (&%h) ? 1 : 2"))) line_map {
388 location_t start_location;
389
390 /* Size and alignment is (usually) 4 bytes. */
391};
392
393/* An ordinary line map encodes physical source locations. Those
394 physical source locations are called "spelling locations".
395
396 Physical source file TO_FILE at line TO_LINE at column 0 is represented
397 by the logical START_LOCATION. TO_LINE+L at column C is represented by
398 START_LOCATION+(L*(1<<m_column_and_range_bits))+(C*1<<m_range_bits), as
399 long as C<(1<<effective range bits), and the result_location is less than
400 the next line_map's start_location.
401 (The top line is line 1 and the leftmost column is column 1; line/column 0
402 means "entire file/line" or "unknown line/column" or "not applicable".)
403
404 The highest possible source location is MAX_LOCATION_T. */
405struct GTY((tag ("1"))) line_map_ordinary : public line_map {
406 /* Base class is 4 bytes. */
407
408 /* 4 bytes of integers, each 1 byte for easy extraction/insertion. */
409
410 /* The reason for creation of this line map. */
411 ENUM_BITFIELD (lc_reason) reason : 8;
412
413 /* SYSP is one for a system header, two for a C system header file
414 that therefore needs to be extern "C" protected in C++, and zero
415 otherwise. This field isn't really needed now that it's in
416 cpp_buffer. */
417 unsigned char sysp;
418
419 /* Number of the low-order location_t bits used for column numbers
420 and ranges. */
421 unsigned int m_column_and_range_bits : 8;
422
423 /* Number of the low-order "column" bits used for storing short ranges
424 inline, rather than in the ad-hoc table.
425 MSB LSB
426 31 0
427 +-------------------------+-------------------------------------------+
428 | |<---map->column_and_range_bits (e.g. 12)-->|
429 +-------------------------+-----------------------+-------------------+
430 | | column_and_range_bits | map->range_bits |
431 | | - range_bits | |
432 +-------------------------+-----------------------+-------------------+
433 | row bits | effective column bits | short range bits |
434 | | (e.g. 7) | (e.g. 5) |
435 +-------------------------+-----------------------+-------------------+ */
436 unsigned int m_range_bits : 8;
437
438 /* Pointer alignment boundary on both 32 and 64-bit systems. */
439
440 const char *to_file;
441 linenum_type to_line;
442
443 /* Location from whence this line map was included. For regular
444 #includes, this location will be the last location of a map. For
445 outermost file, this is 0. For modules it could be anywhere
446 within a map. */
447 location_t included_from;
448
449 /* Size is 20 or 24 bytes, no padding */
450};
451
452/* This is the highest possible source location encoded within an
453 ordinary or macro map. */
454const location_t MAX_LOCATION_T = 0x7FFFFFFF;
455
456struct cpp_hashnode;
457
458/* A macro line map encodes location of tokens coming from a macro
459 expansion.
460
461 The offset from START_LOCATION is used to index into
462 MACRO_LOCATIONS; this holds the original location of the token. */
463struct GTY((tag ("2"))) line_map_macro : public line_map {
464
465 /* Get the location of the expansion point of this macro map. */
466
467 location_t
468 get_expansion_point_location () const
469 {
470 return m_expansion;
471 }
472
473 /* Base is 4 bytes. */
474
475 /* The number of tokens inside the replacement-list of MACRO. */
476 unsigned int n_tokens;
477
478 /* Pointer alignment boundary. */
479
480 /* The cpp macro whose expansion gave birth to this macro map. */
481 struct cpp_hashnode *
482 GTY ((nested_ptr (union tree_node,
483 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
484 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
485 macro;
486
487 /* This array of location is actually an array of pairs of
488 locations. The elements inside it thus look like:
489
490 x0,y0, x1,y1, x2,y2, ...., xn,yn.
491
492 where n == n_tokens;
493
494 Remember that these xI,yI are collected when libcpp is about to
495 expand a given macro.
496
497 yI is the location in the macro definition, either of the token
498 itself or of a macro parameter that it replaces.
499
500 Imagine this:
501
502 #define PLUS(A, B) A + B <--- #1
503
504 int a = PLUS (1,2); <--- #2
505
506 There is a macro map for the expansion of PLUS in #2. PLUS is
507 expanded into its expansion-list. The expansion-list is the
508 replacement-list of PLUS where the macro parameters are replaced
509 with their arguments. So the replacement-list of PLUS is made of
510 the tokens:
511
512 A, +, B
513
514 and the expansion-list is made of the tokens:
515
516 1, +, 2
517
518 Let's consider the case of token "+". Its y1 [yI for I == 1] is
519 its spelling location in #1.
520
521 y0 (thus for token "1") is the spelling location of A in #1.
522
523 And y2 (of token "2") is the spelling location of B in #1.
524
525 When the token is /not/ an argument for a macro, xI is the same
526 location as yI. Otherwise, xI is the location of the token
527 outside this macro expansion. If this macro was expanded from
528 another macro expansion, xI is a virtual location representing
529 the token in that macro expansion; otherwise, it is the spelling
530 location of the token.
531
532 Note that a virtual location is a location returned by
533 linemap_add_macro_token. It encodes the relevant locations (x,y
534 pairs) of that token across the macro expansions from which it
535 (the token) might come from.
536
537 In the example above x1 (for token "+") is going to be the same
538 as y1. x0 is the spelling location for the argument token "1",
539 and x2 is the spelling location for the argument token "2". */
540 location_t * GTY((atomic)) macro_locations;
541
542 /* This is the location of the expansion point of the current macro
543 map. It's the location of the macro name. That location is held
544 by the map that was current right before the current one. It
545 could have been either a macro or an ordinary map, depending on
546 if we are in a nested expansion context not. */
547 location_t m_expansion;
548
549 /* Size is 20 or 32 (4 bytes padding on 64-bit). */
550};
551
552#if CHECKING_P && (GCC_VERSION >= 2007)
553
554/* Assertion macro to be used in line-map code. */
555#define linemap_assert(EXPR) \
556 do { \
557 if (! (EXPR)) \
558 abort (); \
559 } while (0)
560
561/* Assert that becomes a conditional expression when checking is disabled at
562 compilation time. Use this for conditions that should not happen but if
563 they happen, it is better to handle them gracefully rather than crash
564 randomly later.
565 Usage:
566
567 if (linemap_assert_fails(EXPR)) handle_error(); */
568#define linemap_assert_fails(EXPR) __extension__ \
569 ({linemap_assert (EXPR); false;})
570
571#else
572/* Include EXPR, so that unused variable warnings do not occur. */
573#define linemap_assert(EXPR) ((void)(0 && (EXPR)))
574#define linemap_assert_fails(EXPR) (! (EXPR))
575#endif
576
577/* Get whether location LOC is an ordinary location. */
578
579inline bool
580IS_ORDINARY_LOC (location_t loc)
581{
582 return loc < LINE_MAP_MAX_LOCATION;
583}
584
585/* Get whether location LOC is an ad-hoc location. */
586
587inline bool
588IS_ADHOC_LOC (location_t loc)
589{
590 return loc > MAX_LOCATION_T;
591}
592
593/* Categorize line map kinds. */
594
595inline bool
596MAP_ORDINARY_P (const line_map *map)
597{
598 return IS_ORDINARY_LOC (loc: map->start_location);
599}
600
601/* Return TRUE if MAP encodes locations coming from a macro
602 replacement-list at macro expansion point. */
603bool
604linemap_macro_expansion_map_p (const line_map *);
605
606/* Assert that MAP encodes locations of tokens that are not part of
607 the replacement-list of a macro expansion, downcasting from
608 line_map * to line_map_ordinary *. */
609
610inline line_map_ordinary *
611linemap_check_ordinary (line_map *map)
612{
613 linemap_assert (MAP_ORDINARY_P (map));
614 return (line_map_ordinary *)map;
615}
616
617/* Assert that MAP encodes locations of tokens that are not part of
618 the replacement-list of a macro expansion, downcasting from
619 const line_map * to const line_map_ordinary *. */
620
621inline const line_map_ordinary *
622linemap_check_ordinary (const line_map *map)
623{
624 linemap_assert (MAP_ORDINARY_P (map));
625 return (const line_map_ordinary *)map;
626}
627
628/* Assert that MAP is a macro expansion and downcast to the appropriate
629 subclass. */
630
631inline line_map_macro *linemap_check_macro (line_map *map)
632{
633 linemap_assert (!MAP_ORDINARY_P (map));
634 return (line_map_macro *)map;
635}
636
637/* Assert that MAP is a macro expansion and downcast to the appropriate
638 subclass. */
639
640inline const line_map_macro *
641linemap_check_macro (const line_map *map)
642{
643 linemap_assert (!MAP_ORDINARY_P (map));
644 return (const line_map_macro *)map;
645}
646
647/* Read the start location of MAP. */
648
649inline location_t
650MAP_START_LOCATION (const line_map *map)
651{
652 return map->start_location;
653}
654
655/* Get the starting line number of ordinary map MAP. */
656
657inline linenum_type
658ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map)
659{
660 return ord_map->to_line;
661}
662
663/* Return a positive value if map encodes locations from a system
664 header, 0 otherwise. Returns 1 if ordinary map MAP encodes locations
665 in a system header and 2 if it encodes locations in a C system header
666 that therefore needs to be extern "C" protected in C++. */
667
668inline unsigned char
669ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map)
670{
671 return ord_map->sysp;
672}
673
674/* TRUE if this line map is for a module (not a source file). */
675
676inline bool
677MAP_MODULE_P (const line_map *map)
678{
679 return (MAP_ORDINARY_P (map)
680 && linemap_check_ordinary (map)->reason == LC_MODULE);
681}
682
683/* Get the filename of ordinary map MAP. */
684
685inline const char *
686ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map)
687{
688 return ord_map->to_file;
689}
690
691/* Get the cpp macro whose expansion gave birth to macro map MAP. */
692
693inline cpp_hashnode *
694MACRO_MAP_MACRO (const line_map_macro *macro_map)
695{
696 return macro_map->macro;
697}
698
699/* Get the number of tokens inside the replacement-list of the macro
700 that led to macro map MAP. */
701
702inline unsigned int
703MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map)
704{
705 return macro_map->n_tokens;
706}
707
708/* Get the array of pairs of locations within macro map MAP.
709 See the declaration of line_map_macro for more information. */
710
711inline location_t *
712MACRO_MAP_LOCATIONS (const line_map_macro *macro_map)
713{
714 return macro_map->macro_locations;
715}
716
717/* The abstraction of a set of location maps. There can be several
718 types of location maps. This abstraction contains the attributes
719 that are independent from the type of the map.
720
721 Essentially this is just a vector of T_linemap_subclass,
722 which can only ever grow in size. */
723
724struct GTY(()) maps_info_ordinary {
725 /* This array contains the "ordinary" line maps, for all
726 events other than macro expansion
727 (e.g. when a new preprocessing unit starts or ends). */
728 line_map_ordinary * GTY ((length ("%h.used"))) maps;
729
730 /* The total number of allocated maps. */
731 unsigned int allocated;
732
733 /* The number of elements used in maps. This number is smaller
734 or equal to ALLOCATED. */
735 unsigned int used;
736
737 /* The index of the last ordinary map that was looked up with
738 linemap_lookup. */
739 mutable unsigned int m_cache;
740};
741
742struct GTY(()) maps_info_macro {
743 /* This array contains the macro line maps.
744 A macro line map is created whenever a macro expansion occurs. */
745 line_map_macro * GTY ((length ("%h.used"))) maps;
746
747 /* The total number of allocated maps. */
748 unsigned int allocated;
749
750 /* The number of elements used in maps. This number is smaller
751 or equal to ALLOCATED. */
752 unsigned int used;
753
754 /* The index of the last macro map that was looked up with
755 linemap_lookup. */
756 mutable unsigned int m_cache;
757};
758
759/* Data structure to associate a source_range together with an arbitrary
760 data pointer with a source location. */
761struct GTY(()) location_adhoc_data {
762 location_t locus;
763 source_range src_range;
764 void * GTY((skip)) data;
765 unsigned discriminator;
766};
767
768struct htab;
769
770/* The following data structure encodes a location with some adhoc data
771 and maps it to a new unsigned integer (called an adhoc location)
772 that replaces the original location to represent the mapping.
773
774 The new adhoc_loc uses the highest bit as the enabling bit, i.e. if the
775 highest bit is 1, then the number is adhoc_loc. Otherwise, it serves as
776 the original location. Once identified as the adhoc_loc, the lower 31
777 bits of the integer is used to index the location_adhoc_data array,
778 in which the locus and associated data is stored. */
779
780struct GTY(()) location_adhoc_data_map {
781 struct htab * GTY((skip)) htab;
782 location_t curr_loc;
783 unsigned int allocated;
784 struct location_adhoc_data GTY((length ("%h.allocated"))) *data;
785};
786
787/* A set of chronological line_map structures. */
788class GTY(()) line_maps {
789public:
790
791 ~line_maps ();
792
793 bool pure_location_p (location_t loc) const;
794 location_t get_pure_location (location_t loc) const;
795
796 source_range get_range_from_loc (location_t loc) const;
797 location_t get_start (location_t loc) const
798 {
799 return get_range_from_loc (loc).m_start;
800 }
801 location_t
802 get_finish (location_t loc) const
803 {
804 return get_range_from_loc (loc).m_finish;
805 }
806
807 location_t make_location (location_t caret,
808 location_t start,
809 location_t finish);
810
811 location_t
812 get_or_create_combined_loc (location_t locus,
813 source_range src_range,
814 void *data,
815 unsigned discriminator);
816
817 private:
818 bool can_be_stored_compactly_p (location_t locus,
819 source_range src_range,
820 void *data,
821 unsigned discriminator) const;
822 source_range get_range_from_adhoc_loc (location_t loc) const;
823
824 public:
825 maps_info_ordinary info_ordinary;
826
827 maps_info_macro info_macro;
828
829 /* Depth of the include stack, including the current file. */
830 unsigned int depth;
831
832 /* If true, prints an include trace a la -H. */
833 bool trace_includes;
834
835 /* True if we've seen a #line or # 44 "file" directive. */
836 bool seen_line_directive;
837
838 /* Highest location_t "given out". */
839 location_t highest_location;
840
841 /* Start of line of highest location_t "given out". */
842 location_t highest_line;
843
844 /* The maximum column number we can quickly allocate. Higher numbers
845 may require allocating a new line_map. */
846 unsigned int max_column_hint;
847
848 /* The allocator to use when resizing 'maps', defaults to xrealloc. */
849 line_map_realloc GTY((callback)) m_reallocator;
850
851 /* The allocators' function used to know the actual size it
852 allocated, for a certain allocation size requested. */
853 line_map_round_alloc_size_func GTY((callback)) m_round_alloc_size;
854
855 struct location_adhoc_data_map m_location_adhoc_data_map;
856
857 /* The special location value that is used as spelling location for
858 built-in tokens. */
859 location_t builtin_location;
860
861 /* The default value of range_bits in ordinary line maps. */
862 unsigned int default_range_bits;
863
864 unsigned int m_num_optimized_ranges;
865 unsigned int m_num_unoptimized_ranges;
866};
867
868/* Returns the number of allocated maps so far. MAP_KIND shall be TRUE
869 if we are interested in macro maps, FALSE otherwise. */
870inline unsigned int
871LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind)
872{
873 if (map_kind)
874 return set->info_macro.allocated;
875 else
876 return set->info_ordinary.allocated;
877}
878
879/* As above, but by reference (e.g. as an lvalue). */
880
881inline unsigned int &
882LINEMAPS_ALLOCATED (line_maps *set, bool map_kind)
883{
884 if (map_kind)
885 return set->info_macro.allocated;
886 else
887 return set->info_ordinary.allocated;
888}
889
890/* Returns the number of used maps so far. MAP_KIND shall be TRUE if
891 we are interested in macro maps, FALSE otherwise.*/
892inline unsigned int
893LINEMAPS_USED (const line_maps *set, bool map_kind)
894{
895 if (map_kind)
896 return set->info_macro.used;
897 else
898 return set->info_ordinary.used;
899}
900
901/* As above, but by reference (e.g. as an lvalue). */
902
903inline unsigned int &
904LINEMAPS_USED (line_maps *set, bool map_kind)
905{
906 if (map_kind)
907 return set->info_macro.used;
908 else
909 return set->info_ordinary.used;
910}
911
912/* Return the map at a given index. */
913inline line_map *
914LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int index)
915{
916 if (map_kind)
917 return &set->info_macro.maps[index];
918 else
919 return &set->info_ordinary.maps[index];
920}
921
922/* Returns the last map used in the line table SET. MAP_KIND
923 shall be TRUE if we are interested in macro maps, FALSE
924 otherwise.*/
925inline line_map *
926LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind)
927{
928 return LINEMAPS_MAP_AT (set, map_kind,
929 index: LINEMAPS_USED (set, map_kind) - 1);
930}
931
932/* Returns the INDEXth ordinary map. */
933inline line_map_ordinary *
934LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index)
935{
936 linemap_assert (index >= 0
937 && (unsigned int)index < LINEMAPS_USED (set, false));
938 return (line_map_ordinary *)LINEMAPS_MAP_AT (set, map_kind: false, index);
939}
940
941/* Return the number of ordinary maps allocated in the line table
942 SET. */
943inline unsigned int
944LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set)
945{
946 return LINEMAPS_ALLOCATED (set, map_kind: false);
947}
948
949/* Return the number of ordinary maps used in the line table SET. */
950inline unsigned int
951LINEMAPS_ORDINARY_USED (const line_maps *set)
952{
953 return LINEMAPS_USED (set, map_kind: false);
954}
955
956/* Returns a pointer to the last ordinary map used in the line table
957 SET. */
958inline line_map_ordinary *
959LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set)
960{
961 return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, map_kind: false);
962}
963
964/* Returns the INDEXth macro map. */
965inline line_map_macro *
966LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index)
967{
968 linemap_assert (index >= 0
969 && (unsigned int)index < LINEMAPS_USED (set, true));
970 return (line_map_macro *)LINEMAPS_MAP_AT (set, map_kind: true, index);
971}
972
973/* Returns the number of macro maps that were allocated in the line
974 table SET. */
975inline unsigned int
976LINEMAPS_MACRO_ALLOCATED (const line_maps *set)
977{
978 return LINEMAPS_ALLOCATED (set, map_kind: true);
979}
980
981/* Returns the number of macro maps used in the line table SET. */
982inline unsigned int
983LINEMAPS_MACRO_USED (const line_maps *set)
984{
985 return LINEMAPS_USED (set, map_kind: true);
986}
987
988/* Returns the last macro map used in the line table SET. */
989inline line_map_macro *
990LINEMAPS_LAST_MACRO_MAP (const line_maps *set)
991{
992 return (line_map_macro *)LINEMAPS_LAST_MAP (set, map_kind: true);
993}
994
995/* Returns the lowest location [of a token resulting from macro
996 expansion] encoded in this line table. */
997inline location_t
998LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set)
999{
1000 return LINEMAPS_MACRO_USED (set)
1001 ? MAP_START_LOCATION (map: LINEMAPS_LAST_MACRO_MAP (set))
1002 : MAX_LOCATION_T + 1;
1003}
1004
1005extern void *get_data_from_adhoc_loc (const line_maps *, location_t);
1006extern unsigned get_discriminator_from_adhoc_loc (const line_maps *, location_t);
1007extern location_t get_location_from_adhoc_loc (const line_maps *,
1008 location_t);
1009
1010extern source_range get_range_from_loc (const line_maps *set, location_t loc);
1011extern unsigned get_discriminator_from_loc (const line_maps *set, location_t loc);
1012
1013/* Get whether location LOC is a "pure" location, or
1014 whether it is an ad-hoc location, or embeds range information. */
1015
1016bool
1017pure_location_p (const line_maps *set, location_t loc);
1018
1019/* Given location LOC within SET, strip away any packed range information
1020 or ad-hoc information. */
1021
1022extern location_t get_pure_location (const line_maps *set, location_t loc);
1023
1024extern void rebuild_location_adhoc_htab (class line_maps *);
1025
1026/* Initialize a line map set. SET is the line map set to initialize
1027 and BUILTIN_LOCATION is the special location value to be used as
1028 spelling location for built-in tokens. This BUILTIN_LOCATION has
1029 to be strictly less than RESERVED_LOCATION_COUNT. */
1030extern void linemap_init (class line_maps *set,
1031 location_t builtin_location);
1032
1033/* Check for and warn about line_maps entered but not exited. */
1034
1035extern void linemap_check_files_exited (const line_maps *);
1036
1037/* Return a location_t for the start (i.e. column==0) of
1038 (physical) line TO_LINE in the current source file (as in the
1039 most recent linemap_add). MAX_COLUMN_HINT is the highest column
1040 number we expect to use in this line (but it does not change
1041 the highest_location). */
1042
1043extern location_t linemap_line_start
1044(class line_maps *set, linenum_type to_line, unsigned int max_column_hint);
1045
1046/* Allocate a raw block of line maps, zero initialized. */
1047extern line_map *line_map_new_raw (line_maps *, bool, unsigned);
1048
1049/* Add a mapping of logical source line to physical source file and
1050 line number. This function creates an "ordinary map", which is a
1051 map that records locations of tokens that are not part of macro
1052 replacement-lists present at a macro expansion point.
1053
1054 The text pointed to by TO_FILE must have a lifetime
1055 at least as long as the lifetime of SET. An empty
1056 TO_FILE means standard input. If reason is LC_LEAVE, and
1057 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
1058 natural values considering the file we are returning to.
1059
1060 A call to this function can relocate the previous set of
1061 maps, so any stored line_map pointers should not be used. */
1062extern const line_map *linemap_add
1063 (class line_maps *, enum lc_reason, unsigned int sysp,
1064 const char *to_file, linenum_type to_line);
1065
1066/* Create a macro map. A macro map encodes source locations of tokens
1067 that are part of a macro replacement-list, at a macro expansion
1068 point. See the extensive comments of struct line_map and struct
1069 line_map_macro, in line-map.h.
1070
1071 This map shall be created when the macro is expanded. The map
1072 encodes the source location of the expansion point of the macro as
1073 well as the "original" source location of each token that is part
1074 of the macro replacement-list. If a macro is defined but never
1075 expanded, it has no macro map. SET is the set of maps the macro
1076 map should be part of. MACRO_NODE is the macro which the new macro
1077 map should encode source locations for. EXPANSION is the location
1078 of the expansion point of MACRO. For function-like macros
1079 invocations, it's best to make it point to the closing parenthesis
1080 of the macro, rather than the the location of the first character
1081 of the macro. NUM_TOKENS is the number of tokens that are part of
1082 the replacement-list of MACRO. */
1083const line_map_macro *linemap_enter_macro (line_maps *, cpp_hashnode *,
1084 location_t, unsigned int);
1085
1086/* Create a source location for a module. The creator must either do
1087 this after the TU is tokenized, or deal with saving and restoring
1088 map state. */
1089
1090extern location_t linemap_module_loc
1091 (line_maps *, location_t from, const char *name);
1092extern void linemap_module_reparent
1093 (line_maps *, location_t loc, location_t new_parent);
1094
1095/* Restore the linemap state such that the map at LWM-1 continues.
1096 Return start location of the new map. */
1097extern unsigned linemap_module_restore
1098 (line_maps *, unsigned lwm);
1099
1100/* Given a logical source location, returns the map which the
1101 corresponding (source file, line, column) triplet can be deduced
1102 from. Since the set is built chronologically, the logical lines are
1103 monotonic increasing, and so the list is sorted and we can use a
1104 binary search. If no line map have been allocated yet, this
1105 function returns NULL. */
1106extern const line_map *linemap_lookup
1107 (const line_maps *, location_t);
1108
1109unsigned linemap_lookup_macro_index (const line_maps *, location_t);
1110
1111/* Returns TRUE if the line table set tracks token locations across
1112 macro expansion, FALSE otherwise. */
1113bool linemap_tracks_macro_expansion_locs_p (const line_maps *);
1114
1115/* Return the name of the macro associated to MACRO_MAP. */
1116const char* linemap_map_get_macro_name (const line_map_macro *);
1117
1118/* Return a positive value if LOCATION is the locus of a token that is
1119 located in a system header, O otherwise. It returns 1 if LOCATION
1120 is the locus of a token that is located in a system header, and 2
1121 if LOCATION is the locus of a token located in a C system header
1122 that therefore needs to be extern "C" protected in C++.
1123
1124 Note that this function returns 1 if LOCATION belongs to a token
1125 that is part of a macro replacement-list defined in a system
1126 header, but expanded in a non-system file. */
1127int linemap_location_in_system_header_p (const line_maps *,
1128 location_t);
1129
1130/* Return TRUE if LOCATION is a source code location of a token that is part of
1131 a macro expansion, FALSE otherwise. */
1132bool linemap_location_from_macro_expansion_p (const line_maps *,
1133 location_t);
1134
1135/* TRUE if LOCATION is a source code location of a token that is part of the
1136 definition of a macro, FALSE otherwise. */
1137bool linemap_location_from_macro_definition_p (const line_maps *,
1138 location_t);
1139
1140/* With the precondition that LOCATION is the locus of a token that is
1141 an argument of a function-like macro MACRO_MAP and appears in the
1142 expansion of MACRO_MAP, return the locus of that argument in the
1143 context of the caller of MACRO_MAP. */
1144
1145extern location_t
1146linemap_macro_map_loc_unwind_toward_spelling (const line_maps *set,
1147 const line_map_macro *macro_map,
1148 location_t location);
1149
1150/* location_t values from 0 to RESERVED_LOCATION_COUNT-1 will
1151 be reserved for libcpp user as special values, no token from libcpp
1152 will contain any of those locations. */
1153const location_t RESERVED_LOCATION_COUNT = 2;
1154
1155/* Converts a map and a location_t to source line. */
1156inline linenum_type
1157SOURCE_LINE (const line_map_ordinary *ord_map, location_t loc)
1158{
1159 return ((loc - ord_map->start_location)
1160 >> ord_map->m_column_and_range_bits) + ord_map->to_line;
1161}
1162
1163/* Convert a map and location_t to source column number. */
1164inline linenum_type
1165SOURCE_COLUMN (const line_map_ordinary *ord_map, location_t loc)
1166{
1167 return ((loc - ord_map->start_location)
1168 & ((1 << ord_map->m_column_and_range_bits) - 1)) >> ord_map->m_range_bits;
1169}
1170
1171
1172inline location_t
1173linemap_included_from (const line_map_ordinary *ord_map)
1174{
1175 return ord_map->included_from;
1176}
1177
1178/* The linemap containing the included-from location of MAP. */
1179const line_map_ordinary *
1180linemap_included_from_linemap (const line_maps *set,
1181 const line_map_ordinary *map);
1182
1183/* True if the map is at the bottom of the include stack. */
1184
1185inline bool
1186MAIN_FILE_P (const line_map_ordinary *ord_map)
1187{
1188 return ord_map->included_from == 0;
1189}
1190
1191/* Encode and return a location_t from a column number. The
1192 source line considered is the last source line used to call
1193 linemap_line_start, i.e, the last source line which a location was
1194 encoded from. */
1195extern location_t
1196linemap_position_for_column (class line_maps *, unsigned int);
1197
1198/* Encode and return a source location from a given line and
1199 column. */
1200location_t
1201linemap_position_for_line_and_column (line_maps *set,
1202 const line_map_ordinary *,
1203 linenum_type, unsigned int);
1204
1205/* Encode and return a location_t starting from location LOC and
1206 shifting it by OFFSET columns. This function does not support
1207 virtual locations. */
1208location_t
1209linemap_position_for_loc_and_offset (class line_maps *set,
1210 location_t loc,
1211 unsigned int offset);
1212
1213/* Return the file this map is for. */
1214inline const char *
1215LINEMAP_FILE (const line_map_ordinary *ord_map)
1216{
1217 return ord_map->to_file;
1218}
1219
1220/* Return the line number this map started encoding location from. */
1221inline linenum_type
1222LINEMAP_LINE (const line_map_ordinary *ord_map)
1223{
1224 return ord_map->to_line;
1225}
1226
1227/* Return a positive value if map encodes locations from a system
1228 header, 0 otherwise. Returns 1 if MAP encodes locations in a
1229 system header and 2 if it encodes locations in a C system header
1230 that therefore needs to be extern "C" protected in C++. */
1231inline unsigned char
1232LINEMAP_SYSP (const line_map_ordinary *ord_map)
1233{
1234 return ord_map->sysp;
1235}
1236
1237const struct line_map *first_map_in_common (const line_maps *set,
1238 location_t loc0,
1239 location_t loc1,
1240 location_t *res_loc0,
1241 location_t *res_loc1);
1242
1243/* Return a positive value if PRE denotes the location of a token that
1244 comes before the token of POST, 0 if PRE denotes the location of
1245 the same token as the token for POST, and a negative value
1246 otherwise. */
1247int linemap_compare_locations (const line_maps *set,
1248 location_t pre,
1249 location_t post);
1250
1251/* Return TRUE if LOC_A denotes the location a token that comes
1252 topogically before the token denoted by location LOC_B, or if they
1253 are equal. */
1254inline bool
1255linemap_location_before_p (const line_maps *set,
1256 location_t loc_a,
1257 location_t loc_b)
1258{
1259 return linemap_compare_locations (set, pre: loc_a, post: loc_b) >= 0;
1260}
1261
1262typedef struct
1263{
1264 /* The name of the source file involved. */
1265 const char *file;
1266
1267 /* The line-location in the source file. */
1268 int line;
1269
1270 int column;
1271
1272 void *data;
1273
1274 /* In a system header?. */
1275 bool sysp;
1276} expanded_location;
1277
1278/* This is enum is used by the function linemap_resolve_location
1279 below. The meaning of the values is explained in the comment of
1280 that function. */
1281enum location_resolution_kind
1282{
1283 LRK_MACRO_EXPANSION_POINT,
1284 LRK_SPELLING_LOCATION,
1285 LRK_MACRO_DEFINITION_LOCATION
1286};
1287
1288/* Resolve a virtual location into either a spelling location, an
1289 expansion point location or a token argument replacement point
1290 location. Return the map that encodes the virtual location as well
1291 as the resolved location.
1292
1293 If LOC is *NOT* the location of a token resulting from the
1294 expansion of a macro, then the parameter LRK (which stands for
1295 Location Resolution Kind) is ignored and the resulting location
1296 just equals the one given in argument.
1297
1298 Now if LOC *IS* the location of a token resulting from the
1299 expansion of a macro, this is what happens.
1300
1301 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1302 -------------------------------
1303
1304 The virtual location is resolved to the first macro expansion point
1305 that led to this macro expansion.
1306
1307 * If LRK is set to LRK_SPELLING_LOCATION
1308 -------------------------------------
1309
1310 The virtual location is resolved to the locus where the token has
1311 been spelled in the source. This can follow through all the macro
1312 expansions that led to the token.
1313
1314 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1315 --------------------------------------
1316
1317 The virtual location is resolved to the locus of the token in the
1318 context of the macro definition.
1319
1320 If LOC is the locus of a token that is an argument of a
1321 function-like macro [replacing a parameter in the replacement list
1322 of the macro] the virtual location is resolved to the locus of the
1323 parameter that is replaced, in the context of the definition of the
1324 macro.
1325
1326 If LOC is the locus of a token that is not an argument of a
1327 function-like macro, then the function behaves as if LRK was set to
1328 LRK_SPELLING_LOCATION.
1329
1330 If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the
1331 returned location. Note that if the returned location wasn't originally
1332 encoded by a map, the *MAP is set to NULL. This can happen if LOC
1333 resolves to a location reserved for the client code, like
1334 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1335
1336location_t linemap_resolve_location (const line_maps *,
1337 location_t loc,
1338 enum location_resolution_kind lrk,
1339 const line_map_ordinary **loc_map);
1340
1341/* Suppose that LOC is the virtual location of a token coming from the
1342 expansion of a macro M. This function then steps up to get the
1343 location L of the point where M got expanded. If L is a spelling
1344 location inside a macro expansion M', then this function returns
1345 the point where M' was expanded. LOC_MAP is an output parameter.
1346 When non-NULL, *LOC_MAP is set to the map of the returned
1347 location. */
1348location_t linemap_unwind_toward_expansion (const line_maps *,
1349 location_t loc,
1350 const line_map **loc_map);
1351
1352/* If LOC is the virtual location of a token coming from the expansion
1353 of a macro M and if its spelling location is reserved (e.g, a
1354 location for a built-in token), then this function unwinds (using
1355 linemap_unwind_toward_expansion) the location until a location that
1356 is not reserved and is not in a system header is reached. In other
1357 words, this unwinds the reserved location until a location that is
1358 in real source code is reached.
1359
1360 Otherwise, if the spelling location for LOC is not reserved or if
1361 LOC doesn't come from the expansion of a macro, the function
1362 returns LOC as is and *MAP is not touched.
1363
1364 *MAP is set to the map of the returned location if the later is
1365 different from LOC. */
1366location_t linemap_unwind_to_first_non_reserved_loc (const line_maps *,
1367 location_t loc,
1368 const line_map **map);
1369
1370/* Expand source code location LOC and return a user readable source
1371 code location. LOC must be a spelling (non-virtual) location. If
1372 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1373 location is returned. */
1374expanded_location linemap_expand_location (const line_maps *,
1375 const line_map *,
1376 location_t loc);
1377
1378/* Statistics about maps allocation and usage as returned by
1379 linemap_get_statistics. */
1380struct linemap_stats
1381{
1382 long num_ordinary_maps_allocated;
1383 long num_ordinary_maps_used;
1384 long ordinary_maps_allocated_size;
1385 long ordinary_maps_used_size;
1386 long num_expanded_macros;
1387 long num_macro_tokens;
1388 long num_macro_maps_used;
1389 long macro_maps_allocated_size;
1390 long macro_maps_used_size;
1391 long macro_maps_locations_size;
1392 long duplicated_macro_maps_locations_size;
1393 long adhoc_table_size;
1394 long adhoc_table_entries_used;
1395};
1396
1397/* Return the highest location emitted for a given file for which
1398 there is a line map in SET. FILE_NAME is the file name to
1399 consider. If the function returns TRUE, *LOC is set to the highest
1400 location emitted for that file. */
1401bool linemap_get_file_highest_location (const line_maps * set,
1402 const char *file_name,
1403 location_t *loc);
1404
1405/* Compute and return statistics about the memory consumption of some
1406 parts of the line table SET. */
1407void linemap_get_statistics (const line_maps *, struct linemap_stats *);
1408
1409/* Dump debugging information about source location LOC into the file
1410 stream STREAM. SET is the line map set LOC comes from. */
1411void linemap_dump_location (const line_maps *, location_t, FILE *);
1412
1413/* Dump line map at index IX in line table SET to STREAM. If STREAM
1414 is NULL, use stderr. IS_MACRO is true if the caller wants to
1415 dump a macro map, false otherwise. */
1416void linemap_dump (FILE *, const line_maps *, unsigned, bool);
1417
1418/* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
1419 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
1420 specifies how many macro maps to dump. */
1421void line_table_dump (FILE *, const line_maps *, unsigned int, unsigned int);
1422
1423/* An enum for distinguishing the various parts within a location_t. */
1424
1425enum location_aspect
1426{
1427 LOCATION_ASPECT_CARET,
1428 LOCATION_ASPECT_START,
1429 LOCATION_ASPECT_FINISH
1430};
1431
1432/* The rich_location class requires a way to expand location_t instances.
1433 We would directly use expand_location_to_spelling_point, which is
1434 implemented in gcc/input.cc, but we also need to use it for rich_location
1435 within genmatch.cc.
1436 Hence we require client code of libcpp to implement the following
1437 symbol. */
1438extern expanded_location
1439linemap_client_expand_location_to_spelling_point (const line_maps *,
1440 location_t,
1441 enum location_aspect);
1442
1443#endif /* !LIBCPP_LINE_MAP_H */
1444

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