1 /* Map (unsigned int) keys to (source file, line, column) triples.
2 Copyright (C) 2001-2016 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU General Public License as published by the
6 Free Software Foundation; either version 3, or (at your option) any
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; see the file COPYING3. If not see
16 <http://www.gnu.org/licenses/>.
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! */
22 #ifndef LIBCPP_LINE_MAP_H
23 #define LIBCPP_LINE_MAP_H
26 #define GTY(x) /* nothing */
29 /* Reason for creating a new line map with linemap_add. LC_ENTER is
30 when including a new file, e.g. a #include directive in C.
31 LC_LEAVE is when reaching a file's end. LC_RENAME is when a file
32 name or line number changes for neither of the above reasons
33 (e.g. a #line directive in C); LC_RENAME_VERBATIM is like LC_RENAME
34 but a filename of "" is not specially interpreted as standard
35 input. LC_ENTER_MACRO is when a macro expansion is about to start. */
43 /* FIXME: add support for stringize and paste. */
46 /* The type of line numbers. */
47 typedef unsigned int linenum_type
;
49 /* The typedef "source_location" is a key within the location database,
50 identifying a source location or macro expansion, along with range
51 information, and (optionally) a pointer for use by gcc.
53 This key only has meaning in relation to a line_maps instance. Within
54 gcc there is a single line_maps instance: "line_table", declared in
55 gcc/input.h and defined in gcc/input.c.
57 The values of the keys are intended to be internal to libcpp,
58 but for ease-of-understanding the implementation, they are currently
61 Actual | Value | Meaning
62 -----------+-------------------------------+-------------------------------
63 0x00000000 | UNKNOWN_LOCATION (gcc/input.h)| Unknown/invalid location.
64 -----------+-------------------------------+-------------------------------
65 0x00000001 | BUILTINS_LOCATION | The location for declarations
66 | (gcc/input.h) | in "<built-in>"
67 -----------+-------------------------------+-------------------------------
68 0x00000002 | RESERVED_LOCATION_COUNT | The first location to be
69 | (also | handed out, and the
70 | ordmap[0]->start_location) | first line in ordmap 0
71 -----------+-------------------------------+-------------------------------
72 | ordmap[1]->start_location | First line in ordmap 1
73 | ordmap[1]->start_location+32 | First column in that line
74 | (assuming range_bits == 5) |
75 | ordmap[1]->start_location+64 | 2nd column in that line
76 | ordmap[1]->start_location+4096| Second line in ordmap 1
77 | (assuming column_bits == 12)
79 | Subsequent lines are offset by (1 << column_bits),
80 | e.g. 4096 for 12 bits, with a column value of 0 representing
83 | Within a line, the low "range_bits" (typically 5) are used for
84 | storing short ranges, so that there's an offset of
85 | (1 << range_bits) between individual columns within a line,
87 | The low range_bits store the offset of the end point from the
88 | start point, and the start point is found by masking away
92 | ordmap[1]->start_location+64 "2nd column in that line"
93 | above means a caret at that location, with a range
94 | starting and finishing at the same place (the range bits
95 | are 0), a range of length 1.
98 | ordmap[1]->start_location+68
99 | has range bits 0x4, meaning a caret with a range starting at
100 | that location, but with endpoint 4 columns further on: a range
103 | Ranges that have caret != start, or have an endpoint too
104 | far away to fit in range_bits are instead stored as ad-hoc
105 | locations. Hence for range_bits == 5 we can compactly store
106 | tokens of length <= 32 without needing to use the ad-hoc
109 | This packing scheme means we effectively have
110 | (column_bits - range_bits)
111 | of bits for the columns, typically (12 - 5) = 7, for 128
112 | columns; longer line widths are accomodated by starting a
113 | new ordmap with a higher column_bits.
115 | ordmap[2]->start_location-1 | Final location in ordmap 1
116 -----------+-------------------------------+-------------------------------
117 | ordmap[2]->start_location | First line in ordmap 2
118 | ordmap[3]->start_location-1 | Final location in ordmap 2
119 -----------+-------------------------------+-------------------------------
121 -----------+-------------------------------+-------------------------------
122 | ordmap[n-1]->start_location | First line in final ord map
124 | set->highest_location - 1 | Final location in that ordmap
125 -----------+-------------------------------+-------------------------------
126 | set->highest_location | Location of the where the next
127 | | ordinary linemap would start
128 -----------+-------------------------------+-------------------------------
130 | VVVVVVVVVVVVVVVVVVVVVVVVVVV
131 | Ordinary maps grow this way
133 | (unallocated integers)
135 0x60000000 | LINE_MAP_MAX_LOCATION_WITH_COLS
136 | Beyond this point, ordinary linemaps have 0 bits per column:
137 | each increment of the value corresponds to a new source line.
139 0x70000000 | LINE_MAP_MAX_SOURCE_LOCATION
140 | Beyond the point, we give up on ordinary maps; attempts to
141 | create locations in them lead to UNKNOWN_LOCATION (0).
143 | (unallocated integers)
145 | Macro maps grow this way
146 | ^^^^^^^^^^^^^^^^^^^^^^^^
148 -----------+-------------------------------+-------------------------------
149 | LINEMAPS_MACRO_LOWEST_LOCATION| Locations within macro maps
150 | macromap[m-1]->start_location | Start of last macro map
152 -----------+-------------------------------+-------------------------------
153 | macromap[m-2]->start_location | Start of penultimate macro map
154 -----------+-------------------------------+-------------------------------
155 | macromap[1]->start_location | Start of macro map 1
156 -----------+-------------------------------+-------------------------------
157 | macromap[0]->start_location | Start of macro map 0
158 0x7fffffff | MAX_SOURCE_LOCATION | Also used as a mask for
159 | | accessing the ad-hoc data table
160 -----------+-------------------------------+-------------------------------
161 0x80000000 | Start of ad-hoc values; the lower 31 bits are used as an index
162 ... | into the line_table->location_adhoc_data_map.data array.
163 0xffffffff | UINT_MAX |
164 -----------+-------------------------------+-------------------------------
166 Examples of location encoding.
171 Consider encoding the location of a token "foo", seen underlined here
172 on line 523, within an ordinary line_map that starts at line 500:
177 523 return foo + bar;
181 The location's caret and start are both at line 523, column 11; the
182 location's finish is on the same line, at column 13 (an offset of 2
183 columns, for length 3).
185 Line 523 is offset 23 from the starting line of the ordinary line_map.
187 caret == start, and the offset of the finish fits within 5 bits, so
188 this can be stored as a packed range.
192 + (line_offset << ordmap->m_column_and_range_bits)
193 + (column << ordmap->m_range_bits)
195 i.e. (for line offset 23, column 11, range offset 2):
201 ordmap->start + 0x17162
202 assuming that the line_map uses the default of 7 bits for columns and
203 5 bits for packed range (giving 12 bits for m_column_and_range_bits).
209 These are a special case of the above, where
210 caret == start == finish
211 They are stored as packed ranges with offset == 0.
212 For example, the location of the "f" of "foo" could be stored
213 as above, but with range offset 0, giving:
219 ordmap->start + 0x17160
225 Consider encoding the location of the binary expression
231 523 return foo + bar;
235 The location's caret is at the "+", line 523 column 15, but starts
236 earlier, at the "f" of "foo" at column 11. The finish is at the "r"
237 of "bar" at column 19.
239 This can't be stored as a packed range since start != caret.
240 Hence it is stored as an ad-hoc location e.g. 0x80000003.
242 Stripping off the top bit gives us an index into the ad-hoc
245 line_table->location_adhoc_data_map.data[0x3]
247 from which the caret, start and finish can be looked up,
248 encoded as "pure" locations:
250 start == ordmap->start + (23 << 12) + (11 << 5)
251 == ordmap->start + 0x17160 (as above; the "f" of "foo")
253 caret == ordmap->start + (23 << 12) + (15 << 5)
254 == ordmap->start + 0x171e0
256 finish == ordmap->start + (23 << 12) + (19 << 5)
257 == ordmap->start + 0x17260
259 To further see how source_location works in practice, see the
260 worked example in libcpp/location-example.txt. */
261 typedef unsigned int source_location
;
263 /* Do not pack ranges if locations get higher than this.
264 If you change this, update:
265 gcc.dg/plugin/location-overflow-test-*.c. */
266 const source_location LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
= 0x50000000;
268 /* Do not track column numbers if locations get higher than this.
269 If you change this, update:
270 gcc.dg/plugin/location-overflow-test-*.c. */
271 const source_location LINE_MAP_MAX_LOCATION_WITH_COLS
= 0x60000000;
273 /* A range of source locations.
276 m_start is the first location within the range,
277 m_finish is the last location within the range.
279 We may need a more compact way to store these, but for now,
280 let's do it the simple way, as a pair. */
281 struct GTY(()) source_range
283 source_location m_start
;
284 source_location m_finish
;
286 /* We avoid using constructors, since various structs that
287 don't yet have constructors will embed instances of
290 /* Make a source_range from a source_location. */
291 static source_range
from_location (source_location loc
)
294 result
.m_start
= loc
;
295 result
.m_finish
= loc
;
299 /* Make a source_range from a pair of source_location. */
300 static source_range
from_locations (source_location start
,
301 source_location finish
)
304 result
.m_start
= start
;
305 result
.m_finish
= finish
;
309 /* Is there any part of this range on the given line? */
310 bool intersects_line_p (const char *file
, int line
) const;
313 /* Memory allocation function typedef. Works like xrealloc. */
314 typedef void *(*line_map_realloc
) (void *, size_t);
316 /* Memory allocator function that returns the actual allocated size,
317 for a given requested allocation. */
318 typedef size_t (*line_map_round_alloc_size_func
) (size_t);
320 /* A line_map encodes a sequence of locations.
321 There are two kinds of maps. Ordinary maps and macro expansion
322 maps, a.k.a macro maps.
324 A macro map encodes source locations of tokens that are part of a
325 macro replacement-list, at a macro expansion point. E.g, in:
327 #define PLUS(A,B) A + B
329 No macro map is going to be created there, because we are not at a
330 macro expansion point. We are at a macro /definition/ point. So the
331 locations of the tokens of the macro replacement-list (i.e, A + B)
332 will be locations in an ordinary map, not a macro map.
334 On the other hand, if we later do:
338 The invocation of PLUS here is a macro expansion. So we are at a
339 macro expansion point. The preprocessor expands PLUS (1,2) and
340 replaces it with the tokens of its replacement-list: 1 + 2. A macro
341 map is going to be created to hold (or rather to map, haha ...) the
342 locations of the tokens 1, + and 2. The macro map also records the
343 location of the expansion point of PLUS. That location is mapped in
344 the map that is active right before the location of the invocation
346 struct GTY((tag ("0"), desc ("%h.reason == LC_ENTER_MACRO ? 2 : 1"))) line_map
{
347 source_location start_location
;
349 /* The reason for creation of this line map. */
350 ENUM_BITFIELD (lc_reason
) reason
: CHAR_BIT
;
353 /* An ordinary line map encodes physical source locations. Those
354 physical source locations are called "spelling locations".
356 Physical source file TO_FILE at line TO_LINE at column 0 is represented
357 by the logical START_LOCATION. TO_LINE+L at column C is represented by
358 START_LOCATION+(L*(1<<m_column_and_range_bits))+(C*1<<m_range_bits), as
359 long as C<(1<<effective range bits), and the result_location is less than
360 the next line_map's start_location.
361 (The top line is line 1 and the leftmost column is column 1; line/column 0
362 means "entire file/line" or "unknown line/column" or "not applicable".)
364 The highest possible source location is MAX_SOURCE_LOCATION. */
365 struct GTY((tag ("1"))) line_map_ordinary
: public line_map
{
367 linenum_type to_line
;
369 /* An index into the set that gives the line mapping at whose end
370 the current one was included. File(s) at the bottom of the
371 include stack have this set to -1. */
374 /* SYSP is one for a system header, two for a C system header file
375 that therefore needs to be extern "C" protected in C++, and zero
376 otherwise. This field isn't really needed now that it's in
380 /* Number of the low-order source_location bits used for column numbers
382 unsigned int m_column_and_range_bits
: 8;
384 /* Number of the low-order "column" bits used for storing short ranges
385 inline, rather than in the ad-hoc table.
388 +-------------------------+-------------------------------------------+
389 | |<---map->column_and_range_bits (e.g. 12)-->|
390 +-------------------------+-----------------------+-------------------+
391 | | column_and_range_bits | map->range_bits |
393 +-------------------------+-----------------------+-------------------+
394 | row bits | effective column bits | short range bits |
395 | | (e.g. 7) | (e.g. 5) |
396 +-------------------------+-----------------------+-------------------+ */
397 unsigned int m_range_bits
: 8;
400 /* This is the highest possible source location encoded within an
401 ordinary or macro map. */
402 const source_location MAX_SOURCE_LOCATION
= 0x7FFFFFFF;
406 /* A macro line map encodes location of tokens coming from a macro
409 The offset from START_LOCATION is used to index into
410 MACRO_LOCATIONS; this holds the original location of the token. */
411 struct GTY((tag ("2"))) line_map_macro
: public line_map
{
412 /* The cpp macro which expansion gave birth to this macro map. */
413 struct cpp_hashnode
* GTY ((nested_ptr (union tree_node
,
414 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
415 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
418 /* The number of tokens inside the replacement-list of MACRO. */
419 unsigned int n_tokens
;
421 /* This array of location is actually an array of pairs of
422 locations. The elements inside it thus look like:
424 x0,y0, x1,y1, x2,y2, ...., xn,yn.
428 Remember that these xI,yI are collected when libcpp is about to
429 expand a given macro.
431 yI is the location in the macro definition, either of the token
432 itself or of a macro parameter that it replaces.
436 #define PLUS(A, B) A + B <--- #1
438 int a = PLUS (1,2); <--- #2
440 There is a macro map for the expansion of PLUS in #2. PLUS is
441 expanded into its expansion-list. The expansion-list is the
442 replacement-list of PLUS where the macro parameters are replaced
443 with their arguments. So the replacement-list of PLUS is made of
448 and the expansion-list is made of the tokens:
452 Let's consider the case of token "+". Its y1 [yI for I == 1] is
453 its spelling location in #1.
455 y0 (thus for token "1") is the spelling location of A in #1.
457 And y2 (of token "2") is the spelling location of B in #1.
459 When the token is /not/ an argument for a macro, xI is the same
460 location as yI. Otherwise, xI is the location of the token
461 outside this macro expansion. If this macro was expanded from
462 another macro expansion, xI is a virtual location representing
463 the token in that macro expansion; otherwise, it is the spelling
464 location of the token.
466 Note that a virtual location is a location returned by
467 linemap_add_macro_token. It encodes the relevant locations (x,y
468 pairs) of that token across the macro expansions from which it
469 (the token) might come from.
471 In the example above x1 (for token "+") is going to be the same
472 as y1. x0 is the spelling location for the argument token "1",
473 and x2 is the spelling location for the argument token "2". */
474 source_location
* GTY((atomic
)) macro_locations
;
476 /* This is the location of the expansion point of the current macro
477 map. It's the location of the macro name. That location is held
478 by the map that was current right before the current one. It
479 could have been either a macro or an ordinary map, depending on
480 if we are in a nested expansion context not. */
481 source_location expansion
;
484 #if CHECKING_P && (GCC_VERSION >= 2007)
486 /* Assertion macro to be used in line-map code. */
487 #define linemap_assert(EXPR) \
493 /* Assert that becomes a conditional expression when checking is disabled at
494 compilation time. Use this for conditions that should not happen but if
495 they happen, it is better to handle them gracefully rather than crash
499 if (linemap_assert_fails(EXPR)) handle_error(); */
500 #define linemap_assert_fails(EXPR) __extension__ \
501 ({linemap_assert (EXPR); false;})
504 /* Include EXPR, so that unused variable warnings do not occur. */
505 #define linemap_assert(EXPR) ((void)(0 && (EXPR)))
506 #define linemap_assert_fails(EXPR) (! (EXPR))
509 /* Return TRUE if MAP encodes locations coming from a macro
510 replacement-list at macro expansion point. */
512 linemap_macro_expansion_map_p (const struct line_map
*);
514 /* Assert that MAP encodes locations of tokens that are not part of
515 the replacement-list of a macro expansion, downcasting from
516 line_map * to line_map_ordinary *. */
518 inline line_map_ordinary
*
519 linemap_check_ordinary (struct line_map
*map
)
521 linemap_assert (!linemap_macro_expansion_map_p (map
));
522 return (line_map_ordinary
*)map
;
525 /* Assert that MAP encodes locations of tokens that are not part of
526 the replacement-list of a macro expansion, downcasting from
527 const line_map * to const line_map_ordinary *. */
529 inline const line_map_ordinary
*
530 linemap_check_ordinary (const struct line_map
*map
)
532 linemap_assert (!linemap_macro_expansion_map_p (map
));
533 return (const line_map_ordinary
*)map
;
536 /* Assert that MAP is a macro expansion and downcast to the appropriate
539 inline line_map_macro
*linemap_check_macro (line_map
*map
)
541 linemap_assert (linemap_macro_expansion_map_p (map
));
542 return (line_map_macro
*)map
;
545 /* Assert that MAP is a macro expansion and downcast to the appropriate
548 inline const line_map_macro
*
549 linemap_check_macro (const line_map
*map
)
551 linemap_assert (linemap_macro_expansion_map_p (map
));
552 return (const line_map_macro
*)map
;
555 /* Read the start location of MAP. */
557 inline source_location
558 MAP_START_LOCATION (const line_map
*map
)
560 return map
->start_location
;
563 /* Get the starting line number of ordinary map MAP. */
566 ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary
*ord_map
)
568 return ord_map
->to_line
;
571 /* Get the index of the ordinary map at whose end
572 ordinary map MAP was included.
574 File(s) at the bottom of the include stack have this set. */
577 ORDINARY_MAP_INCLUDER_FILE_INDEX (const line_map_ordinary
*ord_map
)
579 return ord_map
->included_from
;
582 /* Return a positive value if map encodes locations from a system
583 header, 0 otherwise. Returns 1 if ordinary map MAP encodes locations
584 in a system header and 2 if it encodes locations in a C system header
585 that therefore needs to be extern "C" protected in C++. */
588 ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary
*ord_map
)
590 return ord_map
->sysp
;
593 /* Get the filename of ordinary map MAP. */
596 ORDINARY_MAP_FILE_NAME (const line_map_ordinary
*ord_map
)
598 return ord_map
->to_file
;
601 /* Get the cpp macro whose expansion gave birth to macro map MAP. */
603 inline cpp_hashnode
*
604 MACRO_MAP_MACRO (const line_map_macro
*macro_map
)
606 return macro_map
->macro
;
609 /* Get the number of tokens inside the replacement-list of the macro
610 that led to macro map MAP. */
613 MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro
*macro_map
)
615 return macro_map
->n_tokens
;
618 /* Get the array of pairs of locations within macro map MAP.
619 See the declaration of line_map_macro for more information. */
621 inline source_location
*
622 MACRO_MAP_LOCATIONS (const line_map_macro
*macro_map
)
624 return macro_map
->macro_locations
;
627 /* Get the location of the expansion point of the macro map MAP. */
629 inline source_location
630 MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro
*macro_map
)
632 return macro_map
->expansion
;
635 /* The abstraction of a set of location maps. There can be several
636 types of location maps. This abstraction contains the attributes
637 that are independent from the type of the map.
639 Essentially this is just a vector of T_linemap_subclass,
640 which can only ever grow in size. */
642 struct GTY(()) maps_info_ordinary
{
643 /* This array contains the "ordinary" line maps, for all
644 events other than macro expansion
645 (e.g. when a new preprocessing unit starts or ends). */
646 line_map_ordinary
* GTY ((length ("%h.used"))) maps
;
648 /* The total number of allocated maps. */
649 unsigned int allocated
;
651 /* The number of elements used in maps. This number is smaller
652 or equal to ALLOCATED. */
658 struct GTY(()) maps_info_macro
{
659 /* This array contains the macro line maps.
660 A macro line map is created whenever a macro expansion occurs. */
661 line_map_macro
* GTY ((length ("%h.used"))) maps
;
663 /* The total number of allocated maps. */
664 unsigned int allocated
;
666 /* The number of elements used in maps. This number is smaller
667 or equal to ALLOCATED. */
673 /* Data structure to associate a source_range together with an arbitrary
674 data pointer with a source location. */
675 struct GTY(()) location_adhoc_data
{
676 source_location locus
;
677 source_range src_range
;
678 void * GTY((skip
)) data
;
683 /* The following data structure encodes a location with some adhoc data
684 and maps it to a new unsigned integer (called an adhoc location)
685 that replaces the original location to represent the mapping.
687 The new adhoc_loc uses the highest bit as the enabling bit, i.e. if the
688 highest bit is 1, then the number is adhoc_loc. Otherwise, it serves as
689 the original location. Once identified as the adhoc_loc, the lower 31
690 bits of the integer is used to index the location_adhoc_data array,
691 in which the locus and associated data is stored. */
693 struct GTY(()) location_adhoc_data_map
{
694 struct htab
* GTY((skip
)) htab
;
695 source_location curr_loc
;
696 unsigned int allocated
;
697 struct location_adhoc_data
GTY((length ("%h.allocated"))) *data
;
700 /* A set of chronological line_map structures. */
701 struct GTY(()) line_maps
{
703 maps_info_ordinary info_ordinary
;
705 maps_info_macro info_macro
;
707 /* Depth of the include stack, including the current file. */
710 /* If true, prints an include trace a la -H. */
713 /* Highest source_location "given out". */
714 source_location highest_location
;
716 /* Start of line of highest source_location "given out". */
717 source_location highest_line
;
719 /* The maximum column number we can quickly allocate. Higher numbers
720 may require allocating a new line_map. */
721 unsigned int max_column_hint
;
723 /* If non-null, the allocator to use when resizing 'maps'. If null,
725 line_map_realloc reallocator
;
727 /* The allocators' function used to know the actual size it
728 allocated, for a certain allocation size requested. */
729 line_map_round_alloc_size_func round_alloc_size
;
731 struct location_adhoc_data_map location_adhoc_data_map
;
733 /* The special location value that is used as spelling location for
735 source_location builtin_location
;
737 /* True if we've seen a #line or # 44 "file" directive. */
738 bool seen_line_directive
;
740 /* The default value of range_bits in ordinary line maps. */
741 unsigned int default_range_bits
;
743 unsigned int num_optimized_ranges
;
744 unsigned int num_unoptimized_ranges
;
747 /* Returns the number of allocated maps so far. MAP_KIND shall be TRUE
748 if we are interested in macro maps, FALSE otherwise. */
750 LINEMAPS_ALLOCATED (const line_maps
*set
, bool map_kind
)
753 return set
->info_macro
.allocated
;
755 return set
->info_ordinary
.allocated
;
758 /* As above, but by reference (e.g. as an lvalue). */
760 inline unsigned int &
761 LINEMAPS_ALLOCATED (line_maps
*set
, bool map_kind
)
764 return set
->info_macro
.allocated
;
766 return set
->info_ordinary
.allocated
;
769 /* Returns the number of used maps so far. MAP_KIND shall be TRUE if
770 we are interested in macro maps, FALSE otherwise.*/
772 LINEMAPS_USED (const line_maps
*set
, bool map_kind
)
775 return set
->info_macro
.used
;
777 return set
->info_ordinary
.used
;
780 /* As above, but by reference (e.g. as an lvalue). */
782 inline unsigned int &
783 LINEMAPS_USED (line_maps
*set
, bool map_kind
)
786 return set
->info_macro
.used
;
788 return set
->info_ordinary
.used
;
791 /* Returns the index of the last map that was looked up with
792 linemap_lookup. MAP_KIND shall be TRUE if we are interested in
793 macro maps, FALSE otherwise. */
795 LINEMAPS_CACHE (const line_maps
*set
, bool map_kind
)
798 return set
->info_macro
.cache
;
800 return set
->info_ordinary
.cache
;
803 /* As above, but by reference (e.g. as an lvalue). */
805 inline unsigned int &
806 LINEMAPS_CACHE (line_maps
*set
, bool map_kind
)
809 return set
->info_macro
.cache
;
811 return set
->info_ordinary
.cache
;
814 /* Return the map at a given index. */
816 LINEMAPS_MAP_AT (const line_maps
*set
, bool map_kind
, int index
)
819 return &set
->info_macro
.maps
[index
];
821 return &set
->info_ordinary
.maps
[index
];
824 /* Returns the last map used in the line table SET. MAP_KIND
825 shall be TRUE if we are interested in macro maps, FALSE
828 LINEMAPS_LAST_MAP (const line_maps
*set
, bool map_kind
)
830 return LINEMAPS_MAP_AT (set
, map_kind
,
831 LINEMAPS_USED (set
, map_kind
) - 1);
834 /* Returns the last map that was allocated in the line table SET.
835 MAP_KIND shall be TRUE if we are interested in macro maps, FALSE
838 LINEMAPS_LAST_ALLOCATED_MAP (const line_maps
*set
, bool map_kind
)
840 return LINEMAPS_MAP_AT (set
, map_kind
,
841 LINEMAPS_ALLOCATED (set
, map_kind
) - 1);
844 /* Returns a pointer to the memory region where ordinary maps are
845 allocated in the line table SET. */
846 inline line_map_ordinary
*
847 LINEMAPS_ORDINARY_MAPS (const line_maps
*set
)
849 return set
->info_ordinary
.maps
;
852 /* Returns the INDEXth ordinary map. */
853 inline line_map_ordinary
*
854 LINEMAPS_ORDINARY_MAP_AT (const line_maps
*set
, int index
)
856 linemap_assert (index
>= 0);
857 linemap_assert ((unsigned int)index
< set
->info_ordinary
.used
);
858 return &set
->info_ordinary
.maps
[index
];
861 /* Return the number of ordinary maps allocated in the line table
864 LINEMAPS_ORDINARY_ALLOCATED (const line_maps
*set
)
866 return LINEMAPS_ALLOCATED (set
, false);
869 /* Return the number of ordinary maps used in the line table SET. */
871 LINEMAPS_ORDINARY_USED (const line_maps
*set
)
873 return LINEMAPS_USED (set
, false);
876 /* Return the index of the last ordinary map that was looked up with
879 LINEMAPS_ORDINARY_CACHE (const line_maps
*set
)
881 return LINEMAPS_CACHE (set
, false);
884 /* As above, but by reference (e.g. as an lvalue). */
886 inline unsigned int &
887 LINEMAPS_ORDINARY_CACHE (line_maps
*set
)
889 return LINEMAPS_CACHE (set
, false);
892 /* Returns a pointer to the last ordinary map used in the line table
894 inline line_map_ordinary
*
895 LINEMAPS_LAST_ORDINARY_MAP (const line_maps
*set
)
897 return (line_map_ordinary
*)LINEMAPS_LAST_MAP (set
, false);
900 /* Returns a pointer to the last ordinary map allocated the line table
902 inline line_map_ordinary
*
903 LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps
*set
)
905 return (line_map_ordinary
*)LINEMAPS_LAST_ALLOCATED_MAP (set
, false);
908 /* Returns a pointer to the beginning of the region where macro maps
910 inline line_map_macro
*
911 LINEMAPS_MACRO_MAPS (const line_maps
*set
)
913 return set
->info_macro
.maps
;
916 /* Returns the INDEXth macro map. */
917 inline line_map_macro
*
918 LINEMAPS_MACRO_MAP_AT (const line_maps
*set
, int index
)
920 linemap_assert (index
>= 0);
921 linemap_assert ((unsigned int)index
< set
->info_macro
.used
);
922 return &set
->info_macro
.maps
[index
];
925 /* Returns the number of macro maps that were allocated in the line
928 LINEMAPS_MACRO_ALLOCATED (const line_maps
*set
)
930 return LINEMAPS_ALLOCATED (set
, true);
933 /* Returns the number of macro maps used in the line table SET. */
935 LINEMAPS_MACRO_USED (const line_maps
*set
)
937 return LINEMAPS_USED (set
, true);
940 /* Returns the index of the last macro map looked up with
943 LINEMAPS_MACRO_CACHE (const line_maps
*set
)
945 return LINEMAPS_CACHE (set
, true);
948 /* As above, but by reference (e.g. as an lvalue). */
950 inline unsigned int &
951 LINEMAPS_MACRO_CACHE (line_maps
*set
)
953 return LINEMAPS_CACHE (set
, true);
956 /* Returns the last macro map used in the line table SET. */
957 inline line_map_macro
*
958 LINEMAPS_LAST_MACRO_MAP (const line_maps
*set
)
960 return (line_map_macro
*)LINEMAPS_LAST_MAP (set
, true);
963 /* Returns the lowest location [of a token resulting from macro
964 expansion] encoded in this line table. */
965 inline source_location
966 LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps
*set
)
968 return LINEMAPS_MACRO_USED (set
)
969 ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set
))
970 : MAX_SOURCE_LOCATION
;
973 /* Returns the last macro map allocated in the line table SET. */
974 inline line_map_macro
*
975 LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps
*set
)
977 return (line_map_macro
*)LINEMAPS_LAST_ALLOCATED_MAP (set
, true);
980 extern void location_adhoc_data_fini (struct line_maps
*);
981 extern source_location
get_combined_adhoc_loc (struct line_maps
*,
985 extern void *get_data_from_adhoc_loc (struct line_maps
*, source_location
);
986 extern source_location
get_location_from_adhoc_loc (struct line_maps
*,
989 extern source_range
get_range_from_loc (line_maps
*set
, source_location loc
);
991 /* Get whether location LOC is an ad-hoc location. */
994 IS_ADHOC_LOC (source_location loc
)
996 return (loc
& MAX_SOURCE_LOCATION
) != loc
;
999 /* Get whether location LOC is a "pure" location, or
1000 whether it is an ad-hoc location, or embeds range information. */
1003 pure_location_p (line_maps
*set
, source_location loc
);
1005 /* Given location LOC within SET, strip away any packed range information
1006 or ad-hoc information. */
1008 extern source_location
get_pure_location (line_maps
*set
,
1009 source_location loc
);
1011 /* Combine LOC and BLOCK, giving a combined adhoc location. */
1013 inline source_location
1014 COMBINE_LOCATION_DATA (struct line_maps
*set
,
1015 source_location loc
,
1016 source_range src_range
,
1019 return get_combined_adhoc_loc (set
, loc
, src_range
, block
);
1022 extern void rebuild_location_adhoc_htab (struct line_maps
*);
1024 /* Initialize a line map set. SET is the line map set to initialize
1025 and BUILTIN_LOCATION is the special location value to be used as
1026 spelling location for built-in tokens. This BUILTIN_LOCATION has
1027 to be strictly less than RESERVED_LOCATION_COUNT. */
1028 extern void linemap_init (struct line_maps
*set
,
1029 source_location builtin_location
);
1031 /* Check for and warn about line_maps entered but not exited. */
1033 extern void linemap_check_files_exited (struct line_maps
*);
1035 /* Return a source_location for the start (i.e. column==0) of
1036 (physical) line TO_LINE in the current source file (as in the
1037 most recent linemap_add). MAX_COLUMN_HINT is the highest column
1038 number we expect to use in this line (but it does not change
1039 the highest_location). */
1041 extern source_location linemap_line_start
1042 (struct line_maps
*set
, linenum_type to_line
, unsigned int max_column_hint
);
1044 /* Add a mapping of logical source line to physical source file and
1045 line number. This function creates an "ordinary map", which is a
1046 map that records locations of tokens that are not part of macro
1047 replacement-lists present at a macro expansion point.
1049 The text pointed to by TO_FILE must have a lifetime
1050 at least as long as the lifetime of SET. An empty
1051 TO_FILE means standard input. If reason is LC_LEAVE, and
1052 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
1053 natural values considering the file we are returning to.
1055 A call to this function can relocate the previous set of
1056 maps, so any stored line_map pointers should not be used. */
1057 extern const struct line_map
*linemap_add
1058 (struct line_maps
*, enum lc_reason
, unsigned int sysp
,
1059 const char *to_file
, linenum_type to_line
);
1061 /* Given a logical source location, returns the map which the
1062 corresponding (source file, line, column) triplet can be deduced
1063 from. Since the set is built chronologically, the logical lines are
1064 monotonic increasing, and so the list is sorted and we can use a
1065 binary search. If no line map have been allocated yet, this
1066 function returns NULL. */
1067 extern const struct line_map
*linemap_lookup
1068 (struct line_maps
*, source_location
);
1070 /* Returns TRUE if the line table set tracks token locations across
1071 macro expansion, FALSE otherwise. */
1072 bool linemap_tracks_macro_expansion_locs_p (struct line_maps
*);
1074 /* Return the name of the macro associated to MACRO_MAP. */
1075 const char* linemap_map_get_macro_name (const line_map_macro
*);
1077 /* Return a positive value if LOCATION is the locus of a token that is
1078 located in a system header, O otherwise. It returns 1 if LOCATION
1079 is the locus of a token that is located in a system header, and 2
1080 if LOCATION is the locus of a token located in a C system header
1081 that therefore needs to be extern "C" protected in C++.
1083 Note that this function returns 1 if LOCATION belongs to a token
1084 that is part of a macro replacement-list defined in a system
1085 header, but expanded in a non-system file. */
1086 int linemap_location_in_system_header_p (struct line_maps
*,
1089 /* Return TRUE if LOCATION is a source code location of a token coming
1090 from a macro replacement-list at a macro expansion point, FALSE
1092 bool linemap_location_from_macro_expansion_p (const struct line_maps
*,
1095 /* With the precondition that LOCATION is the locus of a token that is
1096 an argument of a function-like macro MACRO_MAP and appears in the
1097 expansion of MACRO_MAP, return the locus of that argument in the
1098 context of the caller of MACRO_MAP. */
1100 extern source_location linemap_macro_map_loc_unwind_toward_spelling
1101 (line_maps
*set
, const line_map_macro
*macro_map
, source_location location
);
1103 /* source_location values from 0 to RESERVED_LOCATION_COUNT-1 will
1104 be reserved for libcpp user as special values, no token from libcpp
1105 will contain any of those locations. */
1106 const source_location RESERVED_LOCATION_COUNT
= 2;
1108 /* Converts a map and a source_location to source line. */
1110 SOURCE_LINE (const line_map_ordinary
*ord_map
, source_location loc
)
1112 return ((loc
- ord_map
->start_location
)
1113 >> ord_map
->m_column_and_range_bits
) + ord_map
->to_line
;
1116 /* Convert a map and source_location to source column number. */
1118 SOURCE_COLUMN (const line_map_ordinary
*ord_map
, source_location loc
)
1120 return ((loc
- ord_map
->start_location
)
1121 & ((1 << ord_map
->m_column_and_range_bits
) - 1)) >> ord_map
->m_range_bits
;
1124 /* Return the location of the last source line within an ordinary
1126 inline source_location
1127 LAST_SOURCE_LINE_LOCATION (const line_map_ordinary
*map
)
1129 return (((map
[1].start_location
- 1
1130 - map
->start_location
)
1131 & ~((1 << map
->m_column_and_range_bits
) - 1))
1132 + map
->start_location
);
1135 /* Returns the last source line number within an ordinary map. This
1136 is the (last) line of the #include, or other directive, that caused
1139 LAST_SOURCE_LINE (const line_map_ordinary
*map
)
1141 return SOURCE_LINE (map
, LAST_SOURCE_LINE_LOCATION (map
));
1144 /* Return the last column number within an ordinary map. */
1147 LAST_SOURCE_COLUMN (const line_map_ordinary
*map
)
1149 return SOURCE_COLUMN (map
, LAST_SOURCE_LINE_LOCATION (map
));
1152 /* Returns the map a given map was included from, or NULL if the map
1153 belongs to the main file, i.e, a file that wasn't included by
1155 inline line_map_ordinary
*
1156 INCLUDED_FROM (struct line_maps
*set
, const line_map_ordinary
*ord_map
)
1158 return ((ord_map
->included_from
== -1)
1160 : LINEMAPS_ORDINARY_MAP_AT (set
, ord_map
->included_from
));
1163 /* True if the map is at the bottom of the include stack. */
1166 MAIN_FILE_P (const line_map_ordinary
*ord_map
)
1168 return ord_map
->included_from
< 0;
1171 /* Encode and return a source_location from a column number. The
1172 source line considered is the last source line used to call
1173 linemap_line_start, i.e, the last source line which a location was
1175 extern source_location
1176 linemap_position_for_column (struct line_maps
*, unsigned int);
1178 /* Encode and return a source location from a given line and
1181 linemap_position_for_line_and_column (line_maps
*set
,
1182 const line_map_ordinary
*,
1183 linenum_type
, unsigned int);
1185 /* Encode and return a source_location starting from location LOC and
1186 shifting it by OFFSET columns. This function does not support
1187 virtual locations. */
1189 linemap_position_for_loc_and_offset (struct line_maps
*set
,
1190 source_location loc
,
1191 unsigned int offset
);
1193 /* Return the file this map is for. */
1195 LINEMAP_FILE (const line_map_ordinary
*ord_map
)
1197 return ord_map
->to_file
;
1200 /* Return the line number this map started encoding location from. */
1202 LINEMAP_LINE (const line_map_ordinary
*ord_map
)
1204 return ord_map
->to_line
;
1207 /* Return a positive value if map encodes locations from a system
1208 header, 0 otherwise. Returns 1 if MAP encodes locations in a
1209 system header and 2 if it encodes locations in a C system header
1210 that therefore needs to be extern "C" protected in C++. */
1211 inline unsigned char
1212 LINEMAP_SYSP (const line_map_ordinary
*ord_map
)
1214 return ord_map
->sysp
;
1217 /* Return a positive value if PRE denotes the location of a token that
1218 comes before the token of POST, 0 if PRE denotes the location of
1219 the same token as the token for POST, and a negative value
1221 int linemap_compare_locations (struct line_maps
*set
,
1222 source_location pre
,
1223 source_location post
);
1225 /* Return TRUE if LOC_A denotes the location a token that comes
1226 topogically before the token denoted by location LOC_B, or if they
1229 linemap_location_before_p (struct line_maps
*set
,
1230 source_location loc_a
,
1231 source_location loc_b
)
1233 return linemap_compare_locations (set
, loc_a
, loc_b
) >= 0;
1238 /* The name of the source file involved. */
1241 /* The line-location in the source file. */
1248 /* In a system header?. */
1250 } expanded_location
;
1252 /* Both gcc and emacs number source *lines* starting at 1, but
1253 they have differing conventions for *columns*.
1255 GCC uses a 1-based convention for source columns,
1256 whereas Emacs's M-x column-number-mode uses a 0-based convention.
1258 For example, an error in the initial, left-hand
1259 column of source line 3 is reported by GCC as:
1261 some-file.c:3:1: error: ...etc...
1263 On navigating to the location of that error in Emacs
1264 (e.g. via "next-error"),
1265 the locus is reported in the Mode Line
1266 (assuming M-x column-number-mode) as:
1268 some-file.c 10% (3, 0)
1270 i.e. "3:1:" in GCC corresponds to "(3, 0)" in Emacs. */
1272 /* A location within a rich_location: a caret&range, with
1273 the caret potentially flagged for display. */
1275 struct location_range
1277 source_location m_loc
;
1279 /* Should a caret be drawn for this range? Typically this is
1280 true for the 0th range, and false for subsequent ranges,
1281 but the Fortran frontend overrides this for rendering things like:
1285 Error: Shapes for operands at (1) and (2) are not conformable
1287 where "1" and "2" are notionally carets. */
1288 bool m_show_caret_p
;
1291 /* A partially-embedded vec for use within rich_location for storing
1292 ranges and fix-it hints.
1294 Elements [0..NUM_EMBEDDED) are allocated within m_embed, after
1295 that they are within the dynamically-allocated m_extra.
1297 This allows for static allocation in the common case, whilst
1298 supporting the rarer case of an arbitrary number of elements.
1300 Dynamic allocation is not performed unless it's needed. */
1302 template <typename T
, int NUM_EMBEDDED
>
1303 class semi_embedded_vec
1306 semi_embedded_vec ();
1307 ~semi_embedded_vec ();
1309 unsigned int count () const { return m_num
; }
1310 T
& operator[] (int idx
);
1311 const T
& operator[] (int idx
) const;
1313 void push (const T
&);
1314 void truncate (int len
);
1318 T m_embedded
[NUM_EMBEDDED
];
1323 /* Constructor for semi_embedded_vec. In particular, no dynamic allocation
1326 template <typename T
, int NUM_EMBEDDED
>
1327 semi_embedded_vec
<T
, NUM_EMBEDDED
>::semi_embedded_vec ()
1328 : m_num (0), m_alloc (0), m_extra (NULL
)
1332 /* semi_embedded_vec's dtor. Release any dynamically-allocated memory. */
1334 template <typename T
, int NUM_EMBEDDED
>
1335 semi_embedded_vec
<T
, NUM_EMBEDDED
>::~semi_embedded_vec ()
1337 XDELETEVEC (m_extra
);
1340 /* Look up element IDX, mutably. */
1342 template <typename T
, int NUM_EMBEDDED
>
1344 semi_embedded_vec
<T
, NUM_EMBEDDED
>::operator[] (int idx
)
1346 linemap_assert (idx
< m_num
);
1347 if (idx
< NUM_EMBEDDED
)
1348 return m_embedded
[idx
];
1351 linemap_assert (m_extra
!= NULL
);
1352 return m_extra
[idx
- NUM_EMBEDDED
];
1356 /* Look up element IDX (const). */
1358 template <typename T
, int NUM_EMBEDDED
>
1360 semi_embedded_vec
<T
, NUM_EMBEDDED
>::operator[] (int idx
) const
1362 linemap_assert (idx
< m_num
);
1363 if (idx
< NUM_EMBEDDED
)
1364 return m_embedded
[idx
];
1367 linemap_assert (m_extra
!= NULL
);
1368 return m_extra
[idx
- NUM_EMBEDDED
];
1372 /* Append VALUE to the end of the semi_embedded_vec. */
1374 template <typename T
, int NUM_EMBEDDED
>
1376 semi_embedded_vec
<T
, NUM_EMBEDDED
>::push (const T
& value
)
1379 if (idx
< NUM_EMBEDDED
)
1380 m_embedded
[idx
] = value
;
1383 /* Offset "idx" to be an index within m_extra. */
1384 idx
-= NUM_EMBEDDED
;
1385 if (NULL
== m_extra
)
1387 linemap_assert (m_alloc
== 0);
1389 m_extra
= XNEWVEC (T
, m_alloc
);
1391 else if (idx
>= m_alloc
)
1393 linemap_assert (m_alloc
> 0);
1395 m_extra
= XRESIZEVEC (T
, m_extra
, m_alloc
);
1397 linemap_assert (m_extra
);
1398 linemap_assert (idx
< m_alloc
);
1399 m_extra
[idx
] = value
;
1403 /* Truncate to length LEN. No deallocation is performed. */
1405 template <typename T
, int NUM_EMBEDDED
>
1407 semi_embedded_vec
<T
, NUM_EMBEDDED
>::truncate (int len
)
1409 linemap_assert (len
<= m_num
);
1415 class fixit_replace
;
1417 /* A "rich" source code location, for use when printing diagnostics.
1418 A rich_location has one or more carets&ranges, where the carets
1419 are optional. These are referred to as "ranges" from here.
1420 Typically the zeroth range has a caret; other ranges sometimes
1423 The "primary" location of a rich_location is the caret of range 0,
1424 used for determining the line/column when printing diagnostic
1427 some-file.c:3:1: error: ...etc...
1429 Additional ranges may be added to help the user identify other
1430 pertinent clauses in a diagnostic.
1432 rich_location instances are intended to be allocated on the stack
1433 when generating diagnostics, and to be short-lived.
1435 Examples of rich locations
1436 --------------------------
1442 This "rich" location is simply a single range (range 0), with
1443 caret = start = finish at the given point.
1449 This rich location has a single range (range 0), with the caret
1450 at the first "&", and the start/finish at the parentheses.
1451 Compare with example C below.
1457 This rich location has three ranges:
1458 - Range 0 has its caret and start location at the first "&" and
1459 end at the second "&.
1460 - Range 1 has its start and finish at the "f" and "o" of "foo";
1461 the caret is not flagged for display, but is perhaps at the "f"
1463 - Similarly, range 2 has its start and finish at the "b" and "r" of
1464 "bar"; the caret is not flagged for display, but is perhaps at the
1466 Compare with example B above.
1468 Example D (Fortran frontend)
1469 ****************************
1472 This rich location has range 0 at "1", and range 1 at "2".
1473 Both are flagged for caret display. Both ranges have start/finish
1474 equal to their caret point. The frontend overrides the diagnostic
1475 context's default caret character for these ranges.
1479 printf ("arg0: %i arg1: %s arg2: %i",
1483 This rich location has two ranges:
1484 - range 0 is at the "%s" with start = caret = "%" and finish at
1486 - range 1 has start/finish covering the "101" and is not flagged for
1487 caret printing; it is perhaps at the start of "101". */
1494 /* Constructing from a location. */
1495 rich_location (line_maps
*set
, source_location loc
);
1501 source_location
get_loc () const { return get_loc (0); }
1502 source_location
get_loc (unsigned int idx
) const;
1505 add_range (source_location loc
, bool show_caret_p
);
1508 set_range (line_maps
*set
, unsigned int idx
, source_location loc
,
1511 unsigned int get_num_locations () const { return m_ranges
.count (); }
1513 const location_range
*get_range (unsigned int idx
) const;
1514 location_range
*get_range (unsigned int idx
);
1516 expanded_location
get_expanded_location (unsigned int idx
);
1519 override_column (int column
);
1523 /* Methods for adding insertion fix-it hints. */
1525 /* Suggest inserting NEW_CONTENT at the primary range's caret. */
1527 add_fixit_insert (const char *new_content
);
1529 /* Suggest inserting NEW_CONTENT at WHERE. */
1531 add_fixit_insert (source_location where
,
1532 const char *new_content
);
1534 /* Methods for adding removal fix-it hints. */
1536 /* Suggest removing the content covered by range 0. */
1538 add_fixit_remove ();
1540 /* Suggest removing the content covered between the start and finish
1543 add_fixit_remove (source_location where
);
1545 /* Suggest removing the content covered by SRC_RANGE. */
1547 add_fixit_remove (source_range src_range
);
1549 /* Methods for adding "replace" fix-it hints. */
1551 /* Suggest replacing the content covered by range 0 with NEW_CONTENT. */
1553 add_fixit_replace (const char *new_content
);
1555 /* Suggest replacing the content between the start and finish of
1556 WHERE with NEW_CONTENT. */
1558 add_fixit_replace (source_location where
,
1559 const char *new_content
);
1561 /* Suggest replacing the content covered by SRC_RANGE with
1564 add_fixit_replace (source_range src_range
,
1565 const char *new_content
);
1567 unsigned int get_num_fixit_hints () const { return m_fixit_hints
.count (); }
1568 fixit_hint
*get_fixit_hint (int idx
) const { return m_fixit_hints
[idx
]; }
1569 fixit_hint
*get_last_fixit_hint () const;
1570 bool seen_impossible_fixit_p () const { return m_seen_impossible_fixit
; }
1573 bool reject_impossible_fixit (source_location where
);
1574 void add_fixit (fixit_hint
*hint
);
1577 static const int STATICALLY_ALLOCATED_RANGES
= 3;
1580 line_maps
*m_line_table
;
1581 semi_embedded_vec
<location_range
, STATICALLY_ALLOCATED_RANGES
> m_ranges
;
1583 int m_column_override
;
1585 bool m_have_expanded_location
;
1586 expanded_location m_expanded_location
;
1588 static const int MAX_STATIC_FIXIT_HINTS
= 2;
1589 semi_embedded_vec
<fixit_hint
*, MAX_STATIC_FIXIT_HINTS
> m_fixit_hints
;
1591 bool m_seen_impossible_fixit
;
1597 enum kind
{INSERT
, REPLACE
};
1599 virtual ~fixit_hint () {}
1601 virtual enum kind
get_kind () const = 0;
1602 virtual bool affects_line_p (const char *file
, int line
) const = 0;
1603 virtual source_location
get_start_loc () const = 0;
1604 virtual bool maybe_get_end_loc (source_location
*out
) const = 0;
1605 /* Vfunc for consolidating successor fixits. */
1606 virtual bool maybe_append_replace (line_maps
*set
,
1607 source_range src_range
,
1608 const char *new_content
) = 0;
1611 class fixit_insert
: public fixit_hint
1614 fixit_insert (source_location where
,
1615 const char *new_content
);
1617 enum kind
get_kind () const { return INSERT
; }
1618 bool affects_line_p (const char *file
, int line
) const;
1619 source_location
get_start_loc () const { return m_where
; }
1620 bool maybe_get_end_loc (source_location
*) const { return false; }
1621 bool maybe_append_replace (line_maps
*set
,
1622 source_range src_range
,
1623 const char *new_content
);
1625 source_location
get_location () const { return m_where
; }
1626 const char *get_string () const { return m_bytes
; }
1627 size_t get_length () const { return m_len
; }
1630 source_location m_where
;
1635 class fixit_replace
: public fixit_hint
1638 fixit_replace (source_range src_range
,
1639 const char *new_content
);
1642 enum kind
get_kind () const { return REPLACE
; }
1643 bool affects_line_p (const char *file
, int line
) const;
1644 source_location
get_start_loc () const { return m_src_range
.m_start
; }
1645 bool maybe_get_end_loc (source_location
*out
) const
1647 *out
= m_src_range
.m_finish
;
1650 bool maybe_append_replace (line_maps
*set
,
1651 source_range src_range
,
1652 const char *new_content
);
1654 source_range
get_range () const { return m_src_range
; }
1655 const char *get_string () const { return m_bytes
; }
1656 size_t get_length () const { return m_len
; }
1659 source_range m_src_range
;
1665 /* This is enum is used by the function linemap_resolve_location
1666 below. The meaning of the values is explained in the comment of
1668 enum location_resolution_kind
1670 LRK_MACRO_EXPANSION_POINT
,
1671 LRK_SPELLING_LOCATION
,
1672 LRK_MACRO_DEFINITION_LOCATION
1675 /* Resolve a virtual location into either a spelling location, an
1676 expansion point location or a token argument replacement point
1677 location. Return the map that encodes the virtual location as well
1678 as the resolved location.
1680 If LOC is *NOT* the location of a token resulting from the
1681 expansion of a macro, then the parameter LRK (which stands for
1682 Location Resolution Kind) is ignored and the resulting location
1683 just equals the one given in argument.
1685 Now if LOC *IS* the location of a token resulting from the
1686 expansion of a macro, this is what happens.
1688 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1689 -------------------------------
1691 The virtual location is resolved to the first macro expansion point
1692 that led to this macro expansion.
1694 * If LRK is set to LRK_SPELLING_LOCATION
1695 -------------------------------------
1697 The virtual location is resolved to the locus where the token has
1698 been spelled in the source. This can follow through all the macro
1699 expansions that led to the token.
1701 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1702 --------------------------------------
1704 The virtual location is resolved to the locus of the token in the
1705 context of the macro definition.
1707 If LOC is the locus of a token that is an argument of a
1708 function-like macro [replacing a parameter in the replacement list
1709 of the macro] the virtual location is resolved to the locus of the
1710 parameter that is replaced, in the context of the definition of the
1713 If LOC is the locus of a token that is not an argument of a
1714 function-like macro, then the function behaves as if LRK was set to
1715 LRK_SPELLING_LOCATION.
1717 If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the
1718 returned location. Note that if the returned location wasn't originally
1719 encoded by a map, the *MAP is set to NULL. This can happen if LOC
1720 resolves to a location reserved for the client code, like
1721 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1723 source_location
linemap_resolve_location (struct line_maps
*,
1724 source_location loc
,
1725 enum location_resolution_kind lrk
,
1726 const line_map_ordinary
**loc_map
);
1728 /* Suppose that LOC is the virtual location of a token coming from the
1729 expansion of a macro M. This function then steps up to get the
1730 location L of the point where M got expanded. If L is a spelling
1731 location inside a macro expansion M', then this function returns
1732 the point where M' was expanded. LOC_MAP is an output parameter.
1733 When non-NULL, *LOC_MAP is set to the map of the returned
1735 source_location
linemap_unwind_toward_expansion (struct line_maps
*,
1736 source_location loc
,
1737 const struct line_map
**loc_map
);
1739 /* If LOC is the virtual location of a token coming from the expansion
1740 of a macro M and if its spelling location is reserved (e.g, a
1741 location for a built-in token), then this function unwinds (using
1742 linemap_unwind_toward_expansion) the location until a location that
1743 is not reserved and is not in a system header is reached. In other
1744 words, this unwinds the reserved location until a location that is
1745 in real source code is reached.
1747 Otherwise, if the spelling location for LOC is not reserved or if
1748 LOC doesn't come from the expansion of a macro, the function
1749 returns LOC as is and *MAP is not touched.
1751 *MAP is set to the map of the returned location if the later is
1752 different from LOC. */
1753 source_location
linemap_unwind_to_first_non_reserved_loc (struct line_maps
*,
1754 source_location loc
,
1755 const struct line_map
**map
);
1757 /* Expand source code location LOC and return a user readable source
1758 code location. LOC must be a spelling (non-virtual) location. If
1759 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1760 location is returned. */
1761 expanded_location
linemap_expand_location (struct line_maps
*,
1762 const struct line_map
*,
1763 source_location loc
);
1765 /* Statistics about maps allocation and usage as returned by
1766 linemap_get_statistics. */
1767 struct linemap_stats
1769 long num_ordinary_maps_allocated
;
1770 long num_ordinary_maps_used
;
1771 long ordinary_maps_allocated_size
;
1772 long ordinary_maps_used_size
;
1773 long num_expanded_macros
;
1774 long num_macro_tokens
;
1775 long num_macro_maps_used
;
1776 long macro_maps_allocated_size
;
1777 long macro_maps_used_size
;
1778 long macro_maps_locations_size
;
1779 long duplicated_macro_maps_locations_size
;
1780 long adhoc_table_size
;
1781 long adhoc_table_entries_used
;
1784 /* Return the highest location emitted for a given file for which
1785 there is a line map in SET. FILE_NAME is the file name to
1786 consider. If the function returns TRUE, *LOC is set to the highest
1787 location emitted for that file. */
1788 bool linemap_get_file_highest_location (struct line_maps
* set
,
1789 const char *file_name
,
1790 source_location
*loc
);
1792 /* Compute and return statistics about the memory consumption of some
1793 parts of the line table SET. */
1794 void linemap_get_statistics (struct line_maps
*, struct linemap_stats
*);
1796 /* Dump debugging information about source location LOC into the file
1797 stream STREAM. SET is the line map set LOC comes from. */
1798 void linemap_dump_location (struct line_maps
*, source_location
, FILE *);
1800 /* Dump line map at index IX in line table SET to STREAM. If STREAM
1801 is NULL, use stderr. IS_MACRO is true if the caller wants to
1802 dump a macro map, false otherwise. */
1803 void linemap_dump (FILE *, struct line_maps
*, unsigned, bool);
1805 /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
1806 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
1807 specifies how many macro maps to dump. */
1808 void line_table_dump (FILE *, struct line_maps
*, unsigned int, unsigned int);
1810 /* The rich_location class requires a way to expand source_location instances.
1811 We would directly use expand_location_to_spelling_point, which is
1812 implemented in gcc/input.c, but we also need to use it for rich_location
1814 Hence we require client code of libcpp to implement the following
1816 extern expanded_location
1817 linemap_client_expand_location_to_spelling_point (source_location
);
1819 #endif /* !LIBCPP_LINE_MAP_H */