1 /* Map (unsigned int) keys to (source file, line, column) triples.
2 Copyright (C) 2001-2021 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! */
29 static void trace_include (const line_maps
*, const line_map_ordinary
*);
30 static const line_map_ordinary
* linemap_ordinary_map_lookup (const line_maps
*,
32 static const line_map_macro
* linemap_macro_map_lookup (const line_maps
*,
34 static location_t linemap_macro_map_loc_to_def_point
35 (const line_map_macro
*, location_t
);
36 static location_t linemap_macro_map_loc_to_exp_point
37 (const line_map_macro
*, location_t
);
38 static location_t linemap_macro_loc_to_spelling_point
39 (line_maps
*, location_t
, const line_map_ordinary
**);
40 static location_t
linemap_macro_loc_to_def_point (line_maps
*,
42 const line_map_ordinary
**);
43 static location_t
linemap_macro_loc_to_exp_point (line_maps
*,
45 const line_map_ordinary
**);
47 /* Counters defined in macro.c. */
48 extern unsigned num_expanded_macros_counter
;
49 extern unsigned num_macro_tokens_counter
;
51 /* Destructor for class line_maps.
52 Ensure non-GC-managed memory is released. */
54 line_maps::~line_maps ()
56 if (location_adhoc_data_map
.htab
)
57 htab_delete (location_adhoc_data_map
.htab
);
60 /* Hash function for location_adhoc_data hashtable. */
63 location_adhoc_data_hash (const void *l
)
65 const struct location_adhoc_data
*lb
=
66 (const struct location_adhoc_data
*) l
;
67 return ((hashval_t
) lb
->locus
68 + (hashval_t
) lb
->src_range
.m_start
69 + (hashval_t
) lb
->src_range
.m_finish
73 /* Compare function for location_adhoc_data hashtable. */
76 location_adhoc_data_eq (const void *l1
, const void *l2
)
78 const struct location_adhoc_data
*lb1
=
79 (const struct location_adhoc_data
*) l1
;
80 const struct location_adhoc_data
*lb2
=
81 (const struct location_adhoc_data
*) l2
;
82 return (lb1
->locus
== lb2
->locus
83 && lb1
->src_range
.m_start
== lb2
->src_range
.m_start
84 && lb1
->src_range
.m_finish
== lb2
->src_range
.m_finish
85 && lb1
->data
== lb2
->data
);
88 /* Update the hashtable when location_adhoc_data is reallocated. */
91 location_adhoc_data_update (void **slot
, void *data
)
94 = (char *) ((uintptr_t) *((char **) slot
) + *((ptrdiff_t *) data
));
98 /* Rebuild the hash table from the location adhoc data. */
101 rebuild_location_adhoc_htab (line_maps
*set
)
104 set
->location_adhoc_data_map
.htab
=
105 htab_create (100, location_adhoc_data_hash
, location_adhoc_data_eq
, NULL
);
106 for (i
= 0; i
< set
->location_adhoc_data_map
.curr_loc
; i
++)
107 htab_find_slot (set
->location_adhoc_data_map
.htab
,
108 set
->location_adhoc_data_map
.data
+ i
, INSERT
);
111 /* Helper function for get_combined_adhoc_loc.
112 Can the given LOCUS + SRC_RANGE and DATA pointer be stored compactly
113 within a location_t, without needing to use an ad-hoc location. */
116 can_be_stored_compactly_p (line_maps
*set
,
118 source_range src_range
,
121 /* If there's an ad-hoc pointer, we can't store it directly in the
122 location_t, we need the lookaside. */
126 /* We only store ranges that begin at the locus and that are sufficiently
128 if (src_range
.m_start
!= locus
)
131 if (src_range
.m_finish
< src_range
.m_start
)
134 if (src_range
.m_start
< RESERVED_LOCATION_COUNT
)
137 if (locus
>= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
)
140 /* All 3 locations must be within ordinary maps, typically, the same
142 location_t lowest_macro_loc
= LINEMAPS_MACRO_LOWEST_LOCATION (set
);
143 if (locus
>= lowest_macro_loc
)
145 if (src_range
.m_start
>= lowest_macro_loc
)
147 if (src_range
.m_finish
>= lowest_macro_loc
)
150 /* Passed all tests. */
154 /* Combine LOCUS and DATA to a combined adhoc loc. */
157 get_combined_adhoc_loc (line_maps
*set
,
159 source_range src_range
,
162 struct location_adhoc_data lb
;
163 struct location_adhoc_data
**slot
;
165 if (IS_ADHOC_LOC (locus
))
166 locus
= get_location_from_adhoc_loc (set
, locus
);
167 if (locus
== 0 && data
== NULL
)
170 /* Any ordinary locations ought to be "pure" at this point: no
171 compressed ranges. */
172 linemap_assert (locus
< RESERVED_LOCATION_COUNT
173 || locus
>= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
174 || locus
>= LINEMAPS_MACRO_LOWEST_LOCATION (set
)
175 || pure_location_p (set
, locus
));
177 /* Consider short-range optimization. */
178 if (can_be_stored_compactly_p (set
, locus
, src_range
, data
))
180 /* The low bits ought to be clear. */
181 linemap_assert (pure_location_p (set
, locus
));
182 const line_map
*map
= linemap_lookup (set
, locus
);
183 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
184 unsigned int int_diff
= src_range
.m_finish
- src_range
.m_start
;
185 unsigned int col_diff
= (int_diff
>> ordmap
->m_range_bits
);
186 if (col_diff
< (1U << ordmap
->m_range_bits
))
188 location_t packed
= locus
| col_diff
;
189 set
->num_optimized_ranges
++;
194 /* We can also compactly store locations
195 when locus == start == finish (and data is NULL). */
196 if (locus
== src_range
.m_start
197 && locus
== src_range
.m_finish
202 set
->num_unoptimized_ranges
++;
205 lb
.src_range
= src_range
;
207 slot
= (struct location_adhoc_data
**)
208 htab_find_slot (set
->location_adhoc_data_map
.htab
, &lb
, INSERT
);
211 if (set
->location_adhoc_data_map
.curr_loc
>=
212 set
->location_adhoc_data_map
.allocated
)
214 char *orig_data
= (char *) set
->location_adhoc_data_map
.data
;
216 /* Cast away extern "C" from the type of xrealloc. */
217 line_map_realloc reallocator
= (set
->reallocator
219 : (line_map_realloc
) xrealloc
);
221 if (set
->location_adhoc_data_map
.allocated
== 0)
222 set
->location_adhoc_data_map
.allocated
= 128;
224 set
->location_adhoc_data_map
.allocated
*= 2;
225 set
->location_adhoc_data_map
.data
= (struct location_adhoc_data
*)
226 reallocator (set
->location_adhoc_data_map
.data
,
227 set
->location_adhoc_data_map
.allocated
228 * sizeof (struct location_adhoc_data
));
229 offset
= (char *) (set
->location_adhoc_data_map
.data
) - orig_data
;
230 if (set
->location_adhoc_data_map
.allocated
> 128)
231 htab_traverse (set
->location_adhoc_data_map
.htab
,
232 location_adhoc_data_update
, &offset
);
234 *slot
= set
->location_adhoc_data_map
.data
235 + set
->location_adhoc_data_map
.curr_loc
;
236 set
->location_adhoc_data_map
.data
[set
->location_adhoc_data_map
.curr_loc
++]
239 return ((*slot
) - set
->location_adhoc_data_map
.data
) | 0x80000000;
242 /* Return the data for the adhoc loc. */
245 get_data_from_adhoc_loc (const class line_maps
*set
, location_t loc
)
247 linemap_assert (IS_ADHOC_LOC (loc
));
248 return set
->location_adhoc_data_map
.data
[loc
& MAX_LOCATION_T
].data
;
251 /* Return the location for the adhoc loc. */
254 get_location_from_adhoc_loc (const class line_maps
*set
, location_t loc
)
256 linemap_assert (IS_ADHOC_LOC (loc
));
257 return set
->location_adhoc_data_map
.data
[loc
& MAX_LOCATION_T
].locus
;
260 /* Return the source_range for adhoc location LOC. */
263 get_range_from_adhoc_loc (const class line_maps
*set
, location_t loc
)
265 linemap_assert (IS_ADHOC_LOC (loc
));
266 return set
->location_adhoc_data_map
.data
[loc
& MAX_LOCATION_T
].src_range
;
269 /* Get the source_range of location LOC, either from the ad-hoc
270 lookaside table, or embedded inside LOC itself. */
273 get_range_from_loc (line_maps
*set
,
276 if (IS_ADHOC_LOC (loc
))
277 return get_range_from_adhoc_loc (set
, loc
);
279 /* For ordinary maps, extract packed range. */
280 if (loc
>= RESERVED_LOCATION_COUNT
281 && loc
< LINEMAPS_MACRO_LOWEST_LOCATION (set
)
282 && loc
<= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
)
284 const line_map
*map
= linemap_lookup (set
, loc
);
285 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
287 int offset
= loc
& ((1 << ordmap
->m_range_bits
) - 1);
288 result
.m_start
= loc
- offset
;
289 result
.m_finish
= result
.m_start
+ (offset
<< ordmap
->m_range_bits
);
293 return source_range::from_location (loc
);
296 /* Get whether location LOC is a "pure" location, or
297 whether it is an ad-hoc location, or embeds range information. */
300 pure_location_p (line_maps
*set
, location_t loc
)
302 if (IS_ADHOC_LOC (loc
))
305 const line_map
*map
= linemap_lookup (set
, loc
);
308 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
310 if (loc
& ((1U << ordmap
->m_range_bits
) - 1))
316 /* Given location LOC within SET, strip away any packed range information
317 or ad-hoc information. */
320 get_pure_location (line_maps
*set
, location_t loc
)
322 if (IS_ADHOC_LOC (loc
))
323 loc
= get_location_from_adhoc_loc (set
, loc
);
325 if (loc
>= LINEMAPS_MACRO_LOWEST_LOCATION (set
))
328 if (loc
< RESERVED_LOCATION_COUNT
)
331 const line_map
*map
= linemap_lookup (set
, loc
);
332 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
334 return loc
& ~((1 << ordmap
->m_range_bits
) - 1);
337 /* Initialize a line map set. */
340 linemap_init (line_maps
*set
,
341 location_t builtin_location
)
343 #if __GNUC__ == 4 && __GNUC_MINOR__ == 2 && !defined (__clang__)
344 /* PR33916, needed to fix PR82939. */
345 memset (set
, 0, sizeof (line_maps
));
347 new (set
) line_maps();
349 /* Set default reallocator (used for initial alloc too). */
350 set
->reallocator
= xrealloc
;
351 set
->highest_location
= RESERVED_LOCATION_COUNT
- 1;
352 set
->highest_line
= RESERVED_LOCATION_COUNT
- 1;
353 set
->location_adhoc_data_map
.htab
=
354 htab_create (100, location_adhoc_data_hash
, location_adhoc_data_eq
, NULL
);
355 set
->builtin_location
= builtin_location
;
358 /* Return the ordinary line map from whence MAP was included. Returns
359 NULL if MAP was not an include. */
361 const line_map_ordinary
*
362 linemap_included_from_linemap (line_maps
*set
, const line_map_ordinary
*map
)
364 return linemap_ordinary_map_lookup (set
, linemap_included_from (map
));
367 /* Check for and warn about line_maps entered but not exited. */
370 linemap_check_files_exited (line_maps
*set
)
372 /* Depending upon whether we are handling preprocessed input or
373 not, this can be a user error or an ICE. */
374 for (const line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
376 map
= linemap_included_from_linemap (set
, map
))
377 fprintf (stderr
, "line-map.c: file \"%s\" entered but not left\n",
378 ORDINARY_MAP_FILE_NAME (map
));
381 /* Create NUM zero-initialized maps of type MACRO_P. */
384 line_map_new_raw (line_maps
*set
, bool macro_p
, unsigned num
)
386 unsigned num_maps_allocated
= LINEMAPS_ALLOCATED (set
, macro_p
);
387 unsigned num_maps_used
= LINEMAPS_USED (set
, macro_p
);
389 if (num
> num_maps_allocated
- num_maps_used
)
391 /* We need more space! */
392 if (!num_maps_allocated
)
393 num_maps_allocated
= 128;
394 if (num_maps_allocated
< num_maps_used
+ num
)
395 num_maps_allocated
= num_maps_used
+ num
;
396 num_maps_allocated
*= 2;
398 size_t size_of_a_map
;
402 size_of_a_map
= sizeof (line_map_macro
);
403 buffer
= set
->info_macro
.maps
;
407 size_of_a_map
= sizeof (line_map_ordinary
);
408 buffer
= set
->info_ordinary
.maps
;
411 /* We are going to execute some dance to try to reduce the
412 overhead of the memory allocator, in case we are using the
415 The actual size of memory we are going to get back from the
416 allocator may well be larger than what we ask for. Use this
417 hook to find what that size is. */
419 = set
->round_alloc_size (num_maps_allocated
* size_of_a_map
);
421 /* Now alloc_size contains the exact memory size we would get if
422 we have asked for the initial alloc_size amount of memory.
423 Let's get back to the number of map that amounts to. */
424 unsigned num_maps
= alloc_size
/ size_of_a_map
;
425 buffer
= set
->reallocator (buffer
, num_maps
* size_of_a_map
);
426 memset ((char *)buffer
+ num_maps_used
* size_of_a_map
, 0,
427 (num_maps
- num_maps_used
) * size_of_a_map
);
429 set
->info_macro
.maps
= (line_map_macro
*)buffer
;
431 set
->info_ordinary
.maps
= (line_map_ordinary
*)buffer
;
432 LINEMAPS_ALLOCATED (set
, macro_p
) = num_maps
;
435 line_map
*result
= (macro_p
? (line_map
*)&set
->info_macro
.maps
[num_maps_used
]
436 : (line_map
*)&set
->info_ordinary
.maps
[num_maps_used
]);
437 LINEMAPS_USED (set
, macro_p
) += num
;
442 /* Create a new line map in the line map set SET, and return it.
443 REASON is the reason of creating the map. It determines the type
444 of map created (ordinary or macro map). Note that ordinary maps and
445 macro maps are allocated in different memory location. */
447 static struct line_map
*
448 new_linemap (line_maps
*set
, location_t start_location
)
450 line_map
*result
= line_map_new_raw (set
,
451 start_location
>= LINE_MAP_MAX_LOCATION
,
454 result
->start_location
= start_location
;
459 /* Return the location of the last source line within an ordinary
462 LAST_SOURCE_LINE_LOCATION (const line_map_ordinary
*map
)
464 return (((map
[1].start_location
- 1
465 - map
->start_location
)
466 & ~((1 << map
->m_column_and_range_bits
) - 1))
467 + map
->start_location
);
470 /* Add a mapping of logical source line to physical source file and
473 The text pointed to by TO_FILE must have a lifetime
474 at least as long as the final call to lookup_line (). An empty
475 TO_FILE means standard input. If reason is LC_LEAVE, and
476 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
477 natural values considering the file we are returning to.
479 FROM_LINE should be monotonic increasing across calls to this
480 function. A call to this function can relocate the previous set of
481 maps, so any stored line_map pointers should not be used. */
483 const struct line_map
*
484 linemap_add (line_maps
*set
, enum lc_reason reason
,
485 unsigned int sysp
, const char *to_file
, linenum_type to_line
)
487 /* Generate a start_location above the current highest_location.
488 If possible, make the low range bits be zero. */
489 location_t start_location
= set
->highest_location
+ 1;
490 unsigned range_bits
= 0;
491 if (start_location
< LINE_MAP_MAX_LOCATION_WITH_COLS
)
492 range_bits
= set
->default_range_bits
;
493 start_location
+= (1 << range_bits
) - 1;
494 start_location
&= ~((1 << range_bits
) - 1);
496 linemap_assert (!LINEMAPS_ORDINARY_USED (set
)
498 >= MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set
))));
500 /* When we enter the file for the first time reason cannot be
502 linemap_assert (!(set
->depth
== 0 && reason
== LC_RENAME
));
504 /* If we are leaving the main file, return a NULL map. */
505 if (reason
== LC_LEAVE
506 && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set
))
513 linemap_assert (reason
!= LC_ENTER_MACRO
);
515 if (start_location
>= LINE_MAP_MAX_LOCATION
)
516 /* We ran out of line map space. */
519 line_map_ordinary
*map
520 = linemap_check_ordinary (new_linemap (set
, start_location
));
521 map
->reason
= reason
;
523 if (to_file
&& *to_file
== '\0' && reason
!= LC_RENAME_VERBATIM
)
526 if (reason
== LC_RENAME_VERBATIM
)
529 const line_map_ordinary
*from
= NULL
;
530 if (reason
== LC_LEAVE
)
532 /* When we are just leaving an "included" file, and jump to the next
533 location inside the "includer" right after the #include
534 "included", this variable points the map in use right before the
535 #include "included", inside the same "includer" file. */
537 linemap_assert (!MAIN_FILE_P (map
- 1));
538 /* (MAP - 1) points to the map we are leaving. The
539 map from which (MAP - 1) got included should be the map
540 that comes right before MAP in the same file. */
541 from
= linemap_included_from_linemap (set
, map
- 1);
543 /* A TO_FILE of NULL is special - we use the natural values. */
546 to_file
= ORDINARY_MAP_FILE_NAME (from
);
547 to_line
= SOURCE_LINE (from
, from
[1].start_location
);
548 sysp
= ORDINARY_MAP_IN_SYSTEM_HEADER_P (from
);
551 linemap_assert (filename_cmp (ORDINARY_MAP_FILE_NAME (from
),
556 map
->to_file
= to_file
;
557 map
->to_line
= to_line
;
558 LINEMAPS_ORDINARY_CACHE (set
) = LINEMAPS_ORDINARY_USED (set
) - 1;
559 /* Do not store range_bits here. That's readjusted in
560 linemap_line_start. */
561 map
->m_range_bits
= map
->m_column_and_range_bits
= 0;
562 set
->highest_location
= start_location
;
563 set
->highest_line
= start_location
;
564 set
->max_column_hint
= 0;
566 /* This assertion is placed after set->highest_location has
567 been updated, since the latter affects
568 linemap_location_from_macro_expansion_p, which ultimately affects
570 linemap_assert (pure_location_p (set
, start_location
));
572 if (reason
== LC_ENTER
)
575 map
->included_from
= 0;
577 /* The location of the end of the just-closed map. */
579 = (((map
[0].start_location
- 1 - map
[-1].start_location
)
580 & ~((1 << map
[-1].m_column_and_range_bits
) - 1))
581 + map
[-1].start_location
);
583 if (set
->trace_includes
)
584 trace_include (set
, map
);
586 else if (reason
== LC_RENAME
)
587 map
->included_from
= linemap_included_from (&map
[-1]);
588 else if (reason
== LC_LEAVE
)
591 map
->included_from
= linemap_included_from (from
);
597 /* Create a location for a module NAME imported at FROM. */
600 linemap_module_loc (line_maps
*set
, location_t from
, const char *name
)
602 const line_map_ordinary
*map
603 = linemap_check_ordinary (linemap_add (set
, LC_MODULE
, false, name
, 0));
604 const_cast <line_map_ordinary
*> (map
)->included_from
= from
;
606 location_t loc
= linemap_line_start (set
, 0, 0);
611 /* The linemap containing LOC is being reparented to be
612 imported/included from ADOPTOR. This can happen when an
613 indirectly imported module is then directly imported, or when
614 partitions are involved. */
617 linemap_module_reparent (line_maps
*set
, location_t loc
, location_t adoptor
)
619 const line_map_ordinary
*map
= linemap_ordinary_map_lookup (set
, loc
);
620 const_cast<line_map_ordinary
*> (map
)->included_from
= adoptor
;
623 /* A linemap at LWM-1 was interrupted to insert module locations & imports.
624 Append a new map, continuing the interrupted one. */
627 linemap_module_restore (line_maps
*set
, unsigned lwm
)
629 if (lwm
&& lwm
!= LINEMAPS_USED (set
, false))
631 const line_map_ordinary
*pre_map
632 = linemap_check_ordinary (LINEMAPS_MAP_AT (set
, false, lwm
- 1));
633 unsigned src_line
= SOURCE_LINE (pre_map
,
634 LAST_SOURCE_LINE_LOCATION (pre_map
));
635 location_t inc_at
= pre_map
->included_from
;
636 if (const line_map_ordinary
*post_map
637 = (linemap_check_ordinary
638 (linemap_add (set
, LC_RENAME_VERBATIM
,
639 ORDINARY_MAP_IN_SYSTEM_HEADER_P (pre_map
),
640 ORDINARY_MAP_FILE_NAME (pre_map
), src_line
))))
641 /* linemap_add will think we were included from the same as
642 the preceeding map. */
643 const_cast <line_map_ordinary
*> (post_map
)->included_from
= inc_at
;
647 /* Returns TRUE if the line table set tracks token locations across
648 macro expansion, FALSE otherwise. */
651 linemap_tracks_macro_expansion_locs_p (line_maps
*set
)
653 return LINEMAPS_MACRO_MAPS (set
) != NULL
;
656 /* Create a macro map. A macro map encodes source locations of tokens
657 that are part of a macro replacement-list, at a macro expansion
658 point. See the extensive comments of struct line_map and struct
659 line_map_macro, in line-map.h.
661 This map shall be created when the macro is expanded. The map
662 encodes the source location of the expansion point of the macro as
663 well as the "original" source location of each token that is part
664 of the macro replacement-list. If a macro is defined but never
665 expanded, it has no macro map. SET is the set of maps the macro
666 map should be part of. MACRO_NODE is the macro which the new macro
667 map should encode source locations for. EXPANSION is the location
668 of the expansion point of MACRO. For function-like macros
669 invocations, it's best to make it point to the closing parenthesis
670 of the macro, rather than the the location of the first character
671 of the macro. NUM_TOKENS is the number of tokens that are part of
672 the replacement-list of MACRO.
674 Note that when we run out of the integer space available for source
675 locations, this function returns NULL. In that case, callers of
676 this function cannot encode {line,column} pairs into locations of
677 macro tokens anymore. */
679 const line_map_macro
*
680 linemap_enter_macro (class line_maps
*set
, struct cpp_hashnode
*macro_node
,
681 location_t expansion
, unsigned int num_tokens
)
683 location_t start_location
684 = LINEMAPS_MACRO_LOWEST_LOCATION (set
) - num_tokens
;
686 if (start_location
< LINE_MAP_MAX_LOCATION
)
687 /* We ran out of macro map space. */
690 line_map_macro
*map
= linemap_check_macro (new_linemap (set
, start_location
));
692 map
->macro
= macro_node
;
693 map
->n_tokens
= num_tokens
;
695 = (location_t
*) set
->reallocator (NULL
,
697 * sizeof (location_t
));
698 map
->expansion
= expansion
;
699 memset (MACRO_MAP_LOCATIONS (map
), 0,
700 2 * num_tokens
* sizeof (location_t
));
702 LINEMAPS_MACRO_CACHE (set
) = LINEMAPS_MACRO_USED (set
) - 1;
707 /* Create and return a virtual location for a token that is part of a
708 macro expansion-list at a macro expansion point. See the comment
709 inside struct line_map_macro to see what an expansion-list exactly
712 A call to this function must come after a call to
715 MAP is the map into which the source location is created. TOKEN_NO
716 is the index of the token in the macro replacement-list, starting
719 ORIG_LOC is the location of the token outside of this macro
720 expansion. If the token comes originally from the macro
721 definition, it is the locus in the macro definition; otherwise it
722 is a location in the context of the caller of this macro expansion
723 (which is a virtual location or a source location if the caller is
724 itself a macro expansion or not).
726 ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition,
727 either of the token itself or of a macro parameter that it
731 linemap_add_macro_token (const line_map_macro
*map
,
732 unsigned int token_no
,
734 location_t orig_parm_replacement_loc
)
738 linemap_assert (linemap_macro_expansion_map_p (map
));
739 linemap_assert (token_no
< MACRO_MAP_NUM_MACRO_TOKENS (map
));
741 MACRO_MAP_LOCATIONS (map
)[2 * token_no
] = orig_loc
;
742 MACRO_MAP_LOCATIONS (map
)[2 * token_no
+ 1] = orig_parm_replacement_loc
;
744 result
= MAP_START_LOCATION (map
) + token_no
;
748 /* Return a location_t for the start (i.e. column==0) of
749 (physical) line TO_LINE in the current source file (as in the
750 most recent linemap_add). MAX_COLUMN_HINT is the highest column
751 number we expect to use in this line (but it does not change
752 the highest_location). */
755 linemap_line_start (line_maps
*set
, linenum_type to_line
,
756 unsigned int max_column_hint
)
758 line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
759 location_t highest
= set
->highest_location
;
761 linenum_type last_line
=
762 SOURCE_LINE (map
, set
->highest_line
);
763 int line_delta
= to_line
- last_line
;
764 bool add_map
= false;
765 linemap_assert (map
->m_column_and_range_bits
>= map
->m_range_bits
);
766 int effective_column_bits
= map
->m_column_and_range_bits
- map
->m_range_bits
;
770 && line_delta
* map
->m_column_and_range_bits
> 1000)
771 || (max_column_hint
>= (1U << effective_column_bits
))
772 || (max_column_hint
<= 80 && effective_column_bits
>= 10)
773 || (highest
> LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
774 && map
->m_range_bits
> 0)
775 || (highest
> LINE_MAP_MAX_LOCATION_WITH_COLS
776 && (set
->max_column_hint
|| highest
>= LINE_MAP_MAX_LOCATION
)))
779 max_column_hint
= set
->max_column_hint
;
784 if (max_column_hint
> LINE_MAP_MAX_COLUMN_NUMBER
785 || highest
> LINE_MAP_MAX_LOCATION_WITH_COLS
)
787 /* If the column number is ridiculous or we've allocated a huge
788 number of location_ts, give up on column numbers
789 (and on packed ranges). */
793 if (highest
>= LINE_MAP_MAX_LOCATION
)
799 if (highest
<= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
)
800 range_bits
= set
->default_range_bits
;
803 while (max_column_hint
>= (1U << column_bits
))
805 max_column_hint
= 1U << column_bits
;
806 column_bits
+= range_bits
;
809 /* Allocate the new line_map. However, if the current map only has a
810 single line we can sometimes just increase its column_bits instead. */
812 || last_line
!= ORDINARY_MAP_STARTING_LINE_NUMBER (map
)
813 || SOURCE_COLUMN (map
, highest
) >= (1U << (column_bits
- range_bits
))
814 || ( /* We can't reuse the map if the line offset is sufficiently
815 large to cause overflow when computing location_t values. */
816 (to_line
- ORDINARY_MAP_STARTING_LINE_NUMBER (map
))
818 << (CHAR_BIT
* sizeof (linenum_type
) - column_bits
)))
819 || range_bits
< map
->m_range_bits
)
820 map
= linemap_check_ordinary
821 (const_cast <line_map
*>
822 (linemap_add (set
, LC_RENAME
,
823 ORDINARY_MAP_IN_SYSTEM_HEADER_P (map
),
824 ORDINARY_MAP_FILE_NAME (map
),
826 map
->m_column_and_range_bits
= column_bits
;
827 map
->m_range_bits
= range_bits
;
828 r
= (MAP_START_LOCATION (map
)
829 + ((to_line
- ORDINARY_MAP_STARTING_LINE_NUMBER (map
))
833 r
= set
->highest_line
+ (line_delta
<< map
->m_column_and_range_bits
);
835 /* Locations of ordinary tokens are always lower than locations of
837 if (r
>= LINE_MAP_MAX_LOCATION
)
840 /* Remember we overflowed. */
841 set
->highest_line
= set
->highest_location
= LINE_MAP_MAX_LOCATION
- 1;
842 /* No column numbers! */
843 set
->max_column_hint
= 1;
847 set
->highest_line
= r
;
848 if (r
> set
->highest_location
)
849 set
->highest_location
= r
;
850 set
->max_column_hint
= max_column_hint
;
852 /* At this point, we expect one of:
853 (a) the normal case: a "pure" location with 0 range bits, or
854 (b) we've gone past LINE_MAP_MAX_LOCATION_WITH_COLS so can't track
855 columns anymore (or ranges), or
856 (c) we're in a region with a column hint exceeding
857 LINE_MAP_MAX_COLUMN_NUMBER, so column-tracking is off,
858 with column_bits == 0. */
859 linemap_assert (pure_location_p (set
, r
)
860 || r
>= LINE_MAP_MAX_LOCATION_WITH_COLS
861 || map
->m_column_and_range_bits
== 0);
862 linemap_assert (SOURCE_LINE (map
, r
) == to_line
);
866 /* Encode and return a location_t from a column number. The
867 source line considered is the last source line used to call
868 linemap_line_start, i.e, the last source line which a location was
872 linemap_position_for_column (line_maps
*set
, unsigned int to_column
)
874 location_t r
= set
->highest_line
;
877 (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set
)));
879 if (to_column
>= set
->max_column_hint
)
881 if (r
> LINE_MAP_MAX_LOCATION_WITH_COLS
882 || to_column
> LINE_MAP_MAX_COLUMN_NUMBER
)
884 /* Running low on location_ts - disable column numbers. */
889 /* Otherwise, attempt to start a new line that can hold TO_COLUMN,
890 with some space to spare. This may or may not lead to a new
891 linemap being created. */
892 line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
893 r
= linemap_line_start (set
, SOURCE_LINE (map
, r
), to_column
+ 50);
894 map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
895 if (map
->m_column_and_range_bits
== 0)
897 /* ...then the linemap has column-tracking disabled,
898 presumably due to exceeding either
899 LINE_MAP_MAX_LOCATION_WITH_COLS (overall) or
900 LINE_MAP_MAX_COLUMN_NUMBER (within this line).
901 Return the start of the linemap, which encodes column 0, for
907 line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
908 r
= r
+ (to_column
<< map
->m_range_bits
);
909 if (r
>= set
->highest_location
)
910 set
->highest_location
= r
;
914 /* Encode and return a source location from a given line and
918 linemap_position_for_line_and_column (line_maps
*set
,
919 const line_map_ordinary
*ord_map
,
923 linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map
) <= line
);
925 location_t r
= MAP_START_LOCATION (ord_map
);
926 r
+= ((line
- ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map
))
927 << ord_map
->m_column_and_range_bits
);
928 if (r
<= LINE_MAP_MAX_LOCATION_WITH_COLS
)
929 r
+= ((column
& ((1 << ord_map
->m_column_and_range_bits
) - 1))
930 << ord_map
->m_range_bits
);
931 location_t upper_limit
= LINEMAPS_MACRO_LOWEST_LOCATION (set
);
932 if (r
>= upper_limit
)
934 if (r
> set
->highest_location
)
935 set
->highest_location
= r
;
939 /* Encode and return a location_t starting from location LOC and
940 shifting it by COLUMN_OFFSET columns. This function does not support
941 virtual locations. */
944 linemap_position_for_loc_and_offset (line_maps
*set
,
946 unsigned int column_offset
)
948 const line_map_ordinary
* map
= NULL
;
950 if (IS_ADHOC_LOC (loc
))
951 loc
= get_location_from_adhoc_loc (set
, loc
);
953 /* This function does not support virtual locations yet. */
954 if (linemap_location_from_macro_expansion_p (set
, loc
))
957 if (column_offset
== 0
958 /* Adding an offset to a reserved location (like
959 UNKNOWN_LOCATION for the C/C++ FEs) does not really make
960 sense. So let's leave the location intact in that case. */
961 || loc
< RESERVED_LOCATION_COUNT
)
964 /* We find the real location and shift it. */
965 loc
= linemap_resolve_location (set
, loc
, LRK_SPELLING_LOCATION
, &map
);
966 /* The new location (loc + offset) should be higher than the first
967 location encoded by MAP. This can fail if the line information
968 is messed up because of line directives (see PR66415). */
969 if (MAP_START_LOCATION (map
) >= loc
+ (column_offset
<< map
->m_range_bits
))
972 linenum_type line
= SOURCE_LINE (map
, loc
);
973 unsigned int column
= SOURCE_COLUMN (map
, loc
);
975 /* If MAP is not the last line map of its set, then the new location
976 (loc + offset) should be less than the first location encoded by
977 the next line map of the set. Otherwise, we try to encode the
978 location in the next map. */
979 while (map
!= LINEMAPS_LAST_ORDINARY_MAP (set
)
980 && (loc
+ (column_offset
<< map
->m_range_bits
)
981 >= MAP_START_LOCATION (&map
[1])))
984 /* If the next map starts in a higher line, we cannot encode the
986 if (line
< ORDINARY_MAP_STARTING_LINE_NUMBER (map
))
990 column
+= column_offset
;
992 /* Bail out if the column is not representable within the existing
994 if (column
>= (1u << (map
->m_column_and_range_bits
- map
->m_range_bits
)))
998 linemap_position_for_line_and_column (set
, map
, line
, column
);
999 if (linemap_assert_fails (r
<= set
->highest_location
)
1000 || linemap_assert_fails (map
== linemap_lookup (set
, r
)))
1006 /* Given a virtual source location yielded by a map (either an
1007 ordinary or a macro map), returns that map. */
1009 const struct line_map
*
1010 linemap_lookup (const line_maps
*set
, location_t line
)
1012 if (IS_ADHOC_LOC (line
))
1013 line
= get_location_from_adhoc_loc (set
, line
);
1014 if (linemap_location_from_macro_expansion_p (set
, line
))
1015 return linemap_macro_map_lookup (set
, line
);
1016 return linemap_ordinary_map_lookup (set
, line
);
1019 /* Given a source location yielded by an ordinary map, returns that
1020 map. Since the set is built chronologically, the logical lines are
1021 monotonic increasing, and so the list is sorted and we can use a
1024 static const line_map_ordinary
*
1025 linemap_ordinary_map_lookup (const line_maps
*set
, location_t line
)
1027 if (IS_ADHOC_LOC (line
))
1028 line
= get_location_from_adhoc_loc (set
, line
);
1030 if (set
== NULL
|| line
< RESERVED_LOCATION_COUNT
)
1033 unsigned mn
= LINEMAPS_ORDINARY_CACHE (set
);
1034 unsigned mx
= LINEMAPS_ORDINARY_USED (set
);
1036 const line_map_ordinary
*cached
= LINEMAPS_ORDINARY_MAP_AT (set
, mn
);
1037 /* We should get a segfault if no line_maps have been added yet. */
1038 if (line
>= MAP_START_LOCATION (cached
))
1040 if (mn
+ 1 == mx
|| line
< MAP_START_LOCATION (&cached
[1]))
1051 unsigned md
= (mn
+ mx
) / 2;
1052 if (MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (set
, md
)) > line
)
1058 LINEMAPS_ORDINARY_CACHE (set
) = mn
;
1059 const line_map_ordinary
*result
= LINEMAPS_ORDINARY_MAP_AT (set
, mn
);
1060 linemap_assert (line
>= MAP_START_LOCATION (result
));
1064 /* Given a source location yielded by a macro map, returns that map.
1065 Since the set is built chronologically, the logical lines are
1066 monotonic decreasing, and so the list is sorted and we can use a
1069 static const line_map_macro
*
1070 linemap_macro_map_lookup (const line_maps
*set
, location_t line
)
1072 if (IS_ADHOC_LOC (line
))
1073 line
= get_location_from_adhoc_loc (set
, line
);
1075 linemap_assert (line
>= LINEMAPS_MACRO_LOWEST_LOCATION (set
));
1080 unsigned ix
= linemap_lookup_macro_index (set
, line
);
1081 const struct line_map_macro
*result
= LINEMAPS_MACRO_MAP_AT (set
, ix
);
1082 linemap_assert (MAP_START_LOCATION (result
) <= line
);
1088 linemap_lookup_macro_index (const line_maps
*set
, location_t line
)
1090 unsigned mn
= LINEMAPS_MACRO_CACHE (set
);
1091 unsigned mx
= LINEMAPS_MACRO_USED (set
);
1092 const struct line_map_macro
*cached
= LINEMAPS_MACRO_MAP_AT (set
, mn
);
1094 if (line
>= MAP_START_LOCATION (cached
))
1096 if (line
< (MAP_START_LOCATION (cached
)
1097 + MACRO_MAP_NUM_MACRO_TOKENS (cached
)))
1105 unsigned md
= (mx
+ mn
) / 2;
1106 if (MAP_START_LOCATION (LINEMAPS_MACRO_MAP_AT (set
, md
)) > line
)
1112 LINEMAPS_MACRO_CACHE (set
) = mx
;
1116 /* Return TRUE if MAP encodes locations coming from a macro
1117 replacement-list at macro expansion point. */
1120 linemap_macro_expansion_map_p (const struct line_map
*map
)
1122 return map
&& !MAP_ORDINARY_P (map
);
1125 /* If LOCATION is the locus of a token in a replacement-list of a
1126 macro expansion return the location of the macro expansion point.
1128 Read the comments of struct line_map and struct line_map_macro in
1129 line-map.h to understand what a macro expansion point is. */
1132 linemap_macro_map_loc_to_exp_point (const line_map_macro
*map
,
1133 location_t location ATTRIBUTE_UNUSED
)
1135 linemap_assert (linemap_macro_expansion_map_p (map
)
1136 && location
>= MAP_START_LOCATION (map
));
1138 /* Make sure LOCATION is correct. */
1139 linemap_assert ((location
- MAP_START_LOCATION (map
))
1140 < MACRO_MAP_NUM_MACRO_TOKENS (map
));
1142 return MACRO_MAP_EXPANSION_POINT_LOCATION (map
);
1145 /* LOCATION is the source location of a token that belongs to a macro
1146 replacement-list as part of the macro expansion denoted by MAP.
1148 Return the location of the token at the definition point of the
1152 linemap_macro_map_loc_to_def_point (const line_map_macro
*map
,
1153 location_t location
)
1157 linemap_assert (linemap_macro_expansion_map_p (map
)
1158 && location
>= MAP_START_LOCATION (map
));
1159 linemap_assert (location
>= RESERVED_LOCATION_COUNT
);
1161 token_no
= location
- MAP_START_LOCATION (map
);
1162 linemap_assert (token_no
< MACRO_MAP_NUM_MACRO_TOKENS (map
));
1164 location
= MACRO_MAP_LOCATIONS (map
)[2 * token_no
+ 1];
1169 /* If LOCATION is the locus of a token that is an argument of a
1170 function-like macro M and appears in the expansion of M, return the
1171 locus of that argument in the context of the caller of M.
1173 In other words, this returns the xI location presented in the
1174 comments of line_map_macro above. */
1176 linemap_macro_map_loc_unwind_toward_spelling (line_maps
*set
,
1177 const line_map_macro
* map
,
1178 location_t location
)
1182 if (IS_ADHOC_LOC (location
))
1183 location
= get_location_from_adhoc_loc (set
, location
);
1185 linemap_assert (linemap_macro_expansion_map_p (map
)
1186 && location
>= MAP_START_LOCATION (map
));
1187 linemap_assert (location
>= RESERVED_LOCATION_COUNT
);
1188 linemap_assert (!IS_ADHOC_LOC (location
));
1190 token_no
= location
- MAP_START_LOCATION (map
);
1191 linemap_assert (token_no
< MACRO_MAP_NUM_MACRO_TOKENS (map
));
1193 location
= MACRO_MAP_LOCATIONS (map
)[2 * token_no
];
1198 /* Return the source line number corresponding to source location
1199 LOCATION. SET is the line map set LOCATION comes from. If
1200 LOCATION is the source location of token that is part of the
1201 replacement-list of a macro expansion return the line number of the
1202 macro expansion point. */
1205 linemap_get_expansion_line (line_maps
*set
,
1206 location_t location
)
1208 const line_map_ordinary
*map
= NULL
;
1210 if (IS_ADHOC_LOC (location
))
1211 location
= get_location_from_adhoc_loc (set
, location
);
1213 if (location
< RESERVED_LOCATION_COUNT
)
1217 linemap_macro_loc_to_exp_point (set
, location
, &map
);
1219 return SOURCE_LINE (map
, location
);
1222 /* Return the path of the file corresponding to source code location
1225 If LOCATION is the source location of token that is part of the
1226 replacement-list of a macro expansion return the file path of the
1227 macro expansion point.
1229 SET is the line map set LOCATION comes from. */
1232 linemap_get_expansion_filename (line_maps
*set
,
1233 location_t location
)
1235 const struct line_map_ordinary
*map
= NULL
;
1237 if (IS_ADHOC_LOC (location
))
1238 location
= get_location_from_adhoc_loc (set
, location
);
1240 if (location
< RESERVED_LOCATION_COUNT
)
1243 linemap_macro_loc_to_exp_point (set
, location
, &map
);
1245 return LINEMAP_FILE (map
);
1248 /* Return the name of the macro associated to MACRO_MAP. */
1251 linemap_map_get_macro_name (const line_map_macro
*macro_map
)
1253 linemap_assert (macro_map
&& linemap_macro_expansion_map_p (macro_map
));
1254 return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map
));
1257 /* Return a positive value if LOCATION is the locus of a token that is
1258 located in a system header, O otherwise. It returns 1 if LOCATION
1259 is the locus of a token that is located in a system header, and 2
1260 if LOCATION is the locus of a token located in a C system header
1261 that therefore needs to be extern "C" protected in C++.
1263 Note that this function returns 1 if LOCATION belongs to a token
1264 that is part of a macro replacement-list defined in a system
1265 header, but expanded in a non-system file. */
1268 linemap_location_in_system_header_p (line_maps
*set
,
1269 location_t location
)
1271 const struct line_map
*map
= NULL
;
1273 if (IS_ADHOC_LOC (location
))
1274 location
= get_location_from_adhoc_loc (set
, location
);
1276 if (location
< RESERVED_LOCATION_COUNT
)
1279 /* Let's look at where the token for LOCATION comes from. */
1282 map
= linemap_lookup (set
, location
);
1285 if (!linemap_macro_expansion_map_p (map
))
1286 /* It's a normal token. */
1287 return LINEMAP_SYSP (linemap_check_ordinary (map
));
1290 const line_map_macro
*macro_map
= linemap_check_macro (map
);
1292 /* It's a token resulting from a macro expansion. */
1294 linemap_macro_map_loc_unwind_toward_spelling (set
, macro_map
, location
);
1295 if (loc
< RESERVED_LOCATION_COUNT
)
1296 /* This token might come from a built-in macro. Let's
1297 look at where that macro got expanded. */
1298 location
= linemap_macro_map_loc_to_exp_point (macro_map
, location
);
1309 /* Return TRUE if LOCATION is a source code location of a token that is part of
1310 a macro expansion, FALSE otherwise. */
1313 linemap_location_from_macro_expansion_p (const class line_maps
*set
,
1314 location_t location
)
1316 if (IS_ADHOC_LOC (location
))
1317 location
= get_location_from_adhoc_loc (set
, location
);
1319 return IS_MACRO_LOC (location
);
1322 /* Given two virtual locations *LOC0 and *LOC1, return the first
1323 common macro map in their macro expansion histories. Return NULL
1324 if no common macro was found. *LOC0 (resp. *LOC1) is set to the
1325 virtual location of the token inside the resulting macro. */
1327 static const struct line_map
*
1328 first_map_in_common_1 (line_maps
*set
,
1332 location_t l0
= *loc0
, l1
= *loc1
;
1333 const struct line_map
*map0
= linemap_lookup (set
, l0
);
1334 if (IS_ADHOC_LOC (l0
))
1335 l0
= get_location_from_adhoc_loc (set
, l0
);
1337 const struct line_map
*map1
= linemap_lookup (set
, l1
);
1338 if (IS_ADHOC_LOC (l1
))
1339 l1
= get_location_from_adhoc_loc (set
, l1
);
1341 while (linemap_macro_expansion_map_p (map0
)
1342 && linemap_macro_expansion_map_p (map1
)
1345 if (MAP_START_LOCATION (map0
) < MAP_START_LOCATION (map1
))
1347 l0
= linemap_macro_map_loc_to_exp_point (linemap_check_macro (map0
),
1349 map0
= linemap_lookup (set
, l0
);
1353 l1
= linemap_macro_map_loc_to_exp_point (linemap_check_macro (map1
),
1355 map1
= linemap_lookup (set
, l1
);
1368 /* Given two virtual locations LOC0 and LOC1, return the first common
1369 macro map in their macro expansion histories. Return NULL if no
1370 common macro was found. *RES_LOC0 (resp. *RES_LOC1) is set to the
1371 virtual location of the token inside the resulting macro, upon
1372 return of a non-NULL result. */
1374 const struct line_map
*
1375 first_map_in_common (line_maps
*set
,
1378 location_t
*res_loc0
,
1379 location_t
*res_loc1
)
1384 return first_map_in_common_1 (set
, res_loc0
, res_loc1
);
1387 /* Return a positive value if PRE denotes the location of a token that
1388 comes before the token of POST, 0 if PRE denotes the location of
1389 the same token as the token for POST, and a negative value
1393 linemap_compare_locations (line_maps
*set
,
1397 bool pre_virtual_p
, post_virtual_p
;
1398 location_t l0
= pre
, l1
= post
;
1400 if (IS_ADHOC_LOC (l0
))
1401 l0
= get_location_from_adhoc_loc (set
, l0
);
1402 if (IS_ADHOC_LOC (l1
))
1403 l1
= get_location_from_adhoc_loc (set
, l1
);
1408 if ((pre_virtual_p
= linemap_location_from_macro_expansion_p (set
, l0
)))
1409 l0
= linemap_resolve_location (set
, l0
,
1410 LRK_MACRO_EXPANSION_POINT
,
1413 if ((post_virtual_p
= linemap_location_from_macro_expansion_p (set
, l1
)))
1414 l1
= linemap_resolve_location (set
, l1
,
1415 LRK_MACRO_EXPANSION_POINT
,
1421 && l0
<= LINE_MAP_MAX_LOCATION_WITH_COLS
)
1423 /* So pre and post represent two tokens that are present in a
1424 same macro expansion. Let's see if the token for pre was
1425 before the token for post in that expansion. */
1427 const struct line_map
*map
=
1428 first_map_in_common (set
, pre
, post
, &l0
, &l1
);
1431 /* This should not be possible. */
1434 i0
= l0
- MAP_START_LOCATION (map
);
1435 i1
= l1
- MAP_START_LOCATION (map
);
1439 if (IS_ADHOC_LOC (l0
))
1440 l0
= get_location_from_adhoc_loc (set
, l0
);
1441 if (IS_ADHOC_LOC (l1
))
1442 l1
= get_location_from_adhoc_loc (set
, l1
);
1447 /* Print an include trace, for e.g. the -H option of the preprocessor. */
1450 trace_include (const class line_maps
*set
, const line_map_ordinary
*map
)
1452 unsigned int i
= set
->depth
;
1457 fprintf (stderr
, " %s\n", ORDINARY_MAP_FILE_NAME (map
));
1460 /* Return the spelling location of the token wherever it comes from,
1461 whether part of a macro definition or not.
1463 This is a subroutine for linemap_resolve_location. */
1466 linemap_macro_loc_to_spelling_point (line_maps
*set
,
1467 location_t location
,
1468 const line_map_ordinary
**original_map
)
1470 linemap_assert (set
&& location
>= RESERVED_LOCATION_COUNT
);
1474 const struct line_map
*map
= linemap_lookup (set
, location
);
1475 if (!map
|| MAP_ORDINARY_P (map
))
1478 *original_map
= (const line_map_ordinary
*)map
;
1482 location
= linemap_macro_map_loc_unwind_toward_spelling
1483 (set
, linemap_check_macro (map
), location
);
1489 /* If LOCATION is the source location of a token that belongs to a
1490 macro replacement-list -- as part of a macro expansion -- then
1491 return the location of the token at the definition point of the
1492 macro. Otherwise, return LOCATION. SET is the set of maps
1493 location come from. ORIGINAL_MAP is an output parm. If non NULL,
1494 the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
1495 returned location comes from.
1497 This is a subroutine of linemap_resolve_location. */
1500 linemap_macro_loc_to_def_point (line_maps
*set
,
1501 location_t location
,
1502 const line_map_ordinary
**original_map
)
1504 linemap_assert (set
&& location
>= RESERVED_LOCATION_COUNT
);
1508 location_t caret_loc
= location
;
1509 if (IS_ADHOC_LOC (caret_loc
))
1510 caret_loc
= get_location_from_adhoc_loc (set
, caret_loc
);
1512 const line_map
*map
= linemap_lookup (set
, caret_loc
);
1513 if (!map
|| MAP_ORDINARY_P (map
))
1516 *original_map
= (const line_map_ordinary
*)map
;
1520 location
= linemap_macro_map_loc_to_def_point
1521 (linemap_check_macro (map
), caret_loc
);
1527 /* If LOCATION is the source location of a token that belongs to a
1528 macro replacement-list -- at a macro expansion point -- then return
1529 the location of the topmost expansion point of the macro. We say
1530 topmost because if we are in the context of a nested macro
1531 expansion, the function returns the source location of the first
1532 macro expansion that triggered the nested expansions.
1534 Otherwise, return LOCATION. SET is the set of maps location come
1535 from. ORIGINAL_MAP is an output parm. If non NULL, the function
1536 sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
1537 location comes from.
1539 This is a subroutine of linemap_resolve_location. */
1542 linemap_macro_loc_to_exp_point (line_maps
*set
,
1543 location_t location
,
1544 const line_map_ordinary
**original_map
)
1546 struct line_map
*map
;
1548 if (IS_ADHOC_LOC (location
))
1549 location
= get_location_from_adhoc_loc (set
, location
);
1551 linemap_assert (set
&& location
>= RESERVED_LOCATION_COUNT
);
1555 map
= const_cast <line_map
*> (linemap_lookup (set
, location
));
1556 if (!linemap_macro_expansion_map_p (map
))
1558 location
= linemap_macro_map_loc_to_exp_point (linemap_check_macro (map
),
1563 *original_map
= linemap_check_ordinary (map
);
1567 /* Resolve a virtual location into either a spelling location, an
1568 expansion point location or a token argument replacement point
1569 location. Return the map that encodes the virtual location as well
1570 as the resolved location.
1572 If LOC is *NOT* the location of a token resulting from the
1573 expansion of a macro, then the parameter LRK (which stands for
1574 Location Resolution Kind) is ignored and the resulting location
1575 just equals the one given in argument.
1577 Now if LOC *IS* the location of a token resulting from the
1578 expansion of a macro, this is what happens.
1580 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1581 -------------------------------
1583 The virtual location is resolved to the first macro expansion point
1584 that led to this macro expansion.
1586 * If LRK is set to LRK_SPELLING_LOCATION
1587 -------------------------------------
1589 The virtual location is resolved to the locus where the token has
1590 been spelled in the source. This can follow through all the macro
1591 expansions that led to the token.
1593 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1594 --------------------------------------
1596 The virtual location is resolved to the locus of the token in the
1597 context of the macro definition.
1599 If LOC is the locus of a token that is an argument of a
1600 function-like macro [replacing a parameter in the replacement list
1601 of the macro] the virtual location is resolved to the locus of the
1602 parameter that is replaced, in the context of the definition of the
1605 If LOC is the locus of a token that is not an argument of a
1606 function-like macro, then the function behaves as if LRK was set to
1607 LRK_SPELLING_LOCATION.
1609 If MAP is not NULL, *MAP is set to the map encoding the
1610 returned location. Note that if the returned location wasn't originally
1611 encoded by a map, then *MAP is set to NULL. This can happen if LOC
1612 resolves to a location reserved for the client code, like
1613 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1616 linemap_resolve_location (line_maps
*set
,
1618 enum location_resolution_kind lrk
,
1619 const line_map_ordinary
**map
)
1621 location_t locus
= loc
;
1622 if (IS_ADHOC_LOC (loc
))
1623 locus
= get_location_from_adhoc_loc (set
, loc
);
1625 if (locus
< RESERVED_LOCATION_COUNT
)
1627 /* A reserved location wasn't encoded in a map. Let's return a
1628 NULL map here, just like what linemap_ordinary_map_lookup
1637 case LRK_MACRO_EXPANSION_POINT
:
1638 loc
= linemap_macro_loc_to_exp_point (set
, loc
, map
);
1640 case LRK_SPELLING_LOCATION
:
1641 loc
= linemap_macro_loc_to_spelling_point (set
, loc
, map
);
1643 case LRK_MACRO_DEFINITION_LOCATION
:
1644 loc
= linemap_macro_loc_to_def_point (set
, loc
, map
);
1652 /* TRUE if LOCATION is a source code location of a token that is part of the
1653 definition of a macro, FALSE otherwise. */
1656 linemap_location_from_macro_definition_p (line_maps
*set
,
1659 if (IS_ADHOC_LOC (loc
))
1660 loc
= get_location_from_adhoc_loc (set
, loc
);
1662 if (!linemap_location_from_macro_expansion_p (set
, loc
))
1667 const struct line_map_macro
*map
1668 = linemap_check_macro (linemap_lookup (set
, loc
));
1671 = linemap_macro_map_loc_unwind_toward_spelling (set
, map
, loc
);
1672 if (linemap_location_from_macro_expansion_p (set
, s_loc
))
1677 = linemap_macro_map_loc_to_def_point (map
, loc
);
1678 return s_loc
== def_loc
;
1684 Suppose that LOC is the virtual location of a token T coming from
1685 the expansion of a macro M. This function then steps up to get the
1686 location L of the point where M got expanded. If L is a spelling
1687 location inside a macro expansion M', then this function returns
1688 the locus of the point where M' was expanded. Said otherwise, this
1689 function returns the location of T in the context that triggered
1692 *LOC_MAP must be set to the map of LOC. This function then sets it
1693 to the map of the returned location. */
1696 linemap_unwind_toward_expansion (line_maps
*set
,
1698 const struct line_map
**map
)
1700 location_t resolved_location
;
1701 const line_map_macro
*macro_map
= linemap_check_macro (*map
);
1702 const struct line_map
*resolved_map
;
1704 if (IS_ADHOC_LOC (loc
))
1705 loc
= get_location_from_adhoc_loc (set
, loc
);
1708 linemap_macro_map_loc_unwind_toward_spelling (set
, macro_map
, loc
);
1709 resolved_map
= linemap_lookup (set
, resolved_location
);
1711 if (!linemap_macro_expansion_map_p (resolved_map
))
1713 resolved_location
= linemap_macro_map_loc_to_exp_point (macro_map
, loc
);
1714 resolved_map
= linemap_lookup (set
, resolved_location
);
1717 *map
= resolved_map
;
1718 return resolved_location
;
1721 /* If LOC is the virtual location of a token coming from the expansion
1722 of a macro M and if its spelling location is reserved (e.g, a
1723 location for a built-in token), then this function unwinds (using
1724 linemap_unwind_toward_expansion) the location until a location that
1725 is not reserved and is not in a system header is reached. In other
1726 words, this unwinds the reserved location until a location that is
1727 in real source code is reached.
1729 Otherwise, if the spelling location for LOC is not reserved or if
1730 LOC doesn't come from the expansion of a macro, the function
1731 returns LOC as is and *MAP is not touched.
1733 *MAP is set to the map of the returned location if the later is
1734 different from LOC. */
1736 linemap_unwind_to_first_non_reserved_loc (line_maps
*set
,
1738 const struct line_map
**map
)
1740 location_t resolved_loc
;
1741 const struct line_map
*map0
= NULL
;
1742 const line_map_ordinary
*map1
= NULL
;
1744 if (IS_ADHOC_LOC (loc
))
1745 loc
= get_location_from_adhoc_loc (set
, loc
);
1747 map0
= linemap_lookup (set
, loc
);
1748 if (!linemap_macro_expansion_map_p (map0
))
1751 resolved_loc
= linemap_resolve_location (set
, loc
,
1752 LRK_SPELLING_LOCATION
,
1755 if (resolved_loc
>= RESERVED_LOCATION_COUNT
1756 && !LINEMAP_SYSP (map1
))
1759 while (linemap_macro_expansion_map_p (map0
)
1760 && (resolved_loc
< RESERVED_LOCATION_COUNT
1761 || LINEMAP_SYSP (map1
)))
1763 loc
= linemap_unwind_toward_expansion (set
, loc
, &map0
);
1764 resolved_loc
= linemap_resolve_location (set
, loc
,
1765 LRK_SPELLING_LOCATION
,
1774 /* Expand source code location LOC and return a user readable source
1775 code location. LOC must be a spelling (non-virtual) location. If
1776 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1777 location is returned. */
1780 linemap_expand_location (line_maps
*set
,
1781 const struct line_map
*map
,
1785 expanded_location xloc
;
1787 memset (&xloc
, 0, sizeof (xloc
));
1788 if (IS_ADHOC_LOC (loc
))
1790 xloc
.data
= get_data_from_adhoc_loc (set
, loc
);
1791 loc
= get_location_from_adhoc_loc (set
, loc
);
1794 if (loc
< RESERVED_LOCATION_COUNT
)
1795 /* The location for this token wasn't generated from a line map.
1796 It was probably a location for a builtin token, chosen by some
1797 client code. Let's not try to expand the location in that
1799 else if (map
== NULL
)
1800 /* We shouldn't be getting a NULL map with a location that is not
1801 reserved by the client code. */
1805 /* MAP must be an ordinary map and LOC must be non-virtual,
1806 encoded into this map, obviously; the accessors used on MAP
1807 below ensure it is ordinary. Let's just assert the
1808 non-virtualness of LOC here. */
1809 if (linemap_location_from_macro_expansion_p (set
, loc
))
1812 const line_map_ordinary
*ord_map
= linemap_check_ordinary (map
);
1814 xloc
.file
= LINEMAP_FILE (ord_map
);
1815 xloc
.line
= SOURCE_LINE (ord_map
, loc
);
1816 xloc
.column
= SOURCE_COLUMN (ord_map
, loc
);
1817 xloc
.sysp
= LINEMAP_SYSP (ord_map
) != 0;
1824 /* Dump line map at index IX in line table SET to STREAM. If STREAM
1825 is NULL, use stderr. IS_MACRO is true if the caller wants to
1826 dump a macro map, false otherwise. */
1829 linemap_dump (FILE *stream
, class line_maps
*set
, unsigned ix
, bool is_macro
)
1831 const char *const lc_reasons_v
[LC_HWM
]
1832 = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
1833 "LC_ENTER_MACRO", "LC_MODULE" };
1834 const line_map
*map
;
1842 map
= LINEMAPS_ORDINARY_MAP_AT (set
, ix
);
1843 reason
= linemap_check_ordinary (map
)->reason
;
1847 map
= LINEMAPS_MACRO_MAP_AT (set
, ix
);
1848 reason
= LC_ENTER_MACRO
;
1851 fprintf (stream
, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
1852 ix
, (void *) map
, map
->start_location
,
1853 reason
< LC_HWM
? lc_reasons_v
[reason
] : "???",
1855 && ORDINARY_MAP_IN_SYSTEM_HEADER_P (linemap_check_ordinary (map
)))
1859 const line_map_ordinary
*ord_map
= linemap_check_ordinary (map
);
1860 const line_map_ordinary
*includer_map
1861 = linemap_included_from_linemap (set
, ord_map
);
1863 fprintf (stream
, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map
),
1864 ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map
));
1865 fprintf (stream
, "Included from: [%d] %s\n",
1866 includer_map
? int (includer_map
- set
->info_ordinary
.maps
) : -1,
1867 includer_map
? ORDINARY_MAP_FILE_NAME (includer_map
) : "None");
1871 const line_map_macro
*macro_map
= linemap_check_macro (map
);
1872 fprintf (stream
, "Macro: %s (%u tokens)\n",
1873 linemap_map_get_macro_name (macro_map
),
1874 MACRO_MAP_NUM_MACRO_TOKENS (macro_map
));
1877 fprintf (stream
, "\n");
1881 /* Dump debugging information about source location LOC into the file
1882 stream STREAM. SET is the line map set LOC comes from. */
1885 linemap_dump_location (line_maps
*set
,
1889 const line_map_ordinary
*map
;
1890 location_t location
;
1891 const char *path
= "", *from
= "";
1892 int l
= -1, c
= -1, s
= -1, e
= -1;
1894 if (IS_ADHOC_LOC (loc
))
1895 loc
= get_location_from_adhoc_loc (set
, loc
);
1901 linemap_resolve_location (set
, loc
, LRK_MACRO_DEFINITION_LOCATION
, &map
);
1904 /* Only reserved locations can be tolerated in this case. */
1905 linemap_assert (location
< RESERVED_LOCATION_COUNT
);
1908 path
= LINEMAP_FILE (map
);
1909 l
= SOURCE_LINE (map
, location
);
1910 c
= SOURCE_COLUMN (map
, location
);
1911 s
= LINEMAP_SYSP (map
) != 0;
1912 e
= location
!= loc
;
1917 const line_map_ordinary
*from_map
1918 = linemap_included_from_linemap (set
, map
);
1919 from
= from_map
? LINEMAP_FILE (from_map
) : "<NULL>";
1923 /* P: path, L: line, C: column, S: in-system-header, M: map address,
1924 E: macro expansion?, LOC: original location, R: resolved location */
1925 fprintf (stream
, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}",
1926 path
, from
, l
, c
, s
, (void*)map
, e
, loc
, location
);
1929 /* Return the highest location emitted for a given file for which
1930 there is a line map in SET. FILE_NAME is the file name to
1931 consider. If the function returns TRUE, *LOC is set to the highest
1932 location emitted for that file. */
1935 linemap_get_file_highest_location (line_maps
*set
,
1936 const char *file_name
,
1939 /* If the set is empty or no ordinary map has been created then
1940 there is no file to look for ... */
1941 if (set
== NULL
|| set
->info_ordinary
.used
== 0)
1944 /* Now look for the last ordinary map created for FILE_NAME. */
1946 for (i
= set
->info_ordinary
.used
- 1; i
>= 0; --i
)
1948 const char *fname
= set
->info_ordinary
.maps
[i
].to_file
;
1949 if (fname
&& !filename_cmp (fname
, file_name
))
1956 /* The highest location for a given map is either the starting
1957 location of the next map minus one, or -- if the map is the
1958 latest one -- the highest location of the set. */
1960 if (i
== (int) set
->info_ordinary
.used
- 1)
1961 result
= set
->highest_location
;
1963 result
= set
->info_ordinary
.maps
[i
+ 1].start_location
- 1;
1969 /* Compute and return statistics about the memory consumption of some
1970 parts of the line table SET. */
1973 linemap_get_statistics (line_maps
*set
,
1974 struct linemap_stats
*s
)
1976 long ordinary_maps_allocated_size
, ordinary_maps_used_size
,
1977 macro_maps_allocated_size
, macro_maps_used_size
,
1978 macro_maps_locations_size
= 0, duplicated_macro_maps_locations_size
= 0;
1980 const line_map_macro
*cur_map
;
1982 ordinary_maps_allocated_size
=
1983 LINEMAPS_ORDINARY_ALLOCATED (set
) * sizeof (struct line_map_ordinary
);
1985 ordinary_maps_used_size
=
1986 LINEMAPS_ORDINARY_USED (set
) * sizeof (struct line_map_ordinary
);
1988 macro_maps_allocated_size
=
1989 LINEMAPS_MACRO_ALLOCATED (set
) * sizeof (struct line_map_macro
);
1991 for (cur_map
= LINEMAPS_MACRO_MAPS (set
);
1992 cur_map
&& cur_map
<= LINEMAPS_LAST_MACRO_MAP (set
);
1997 linemap_assert (linemap_macro_expansion_map_p (cur_map
));
1999 macro_maps_locations_size
+=
2000 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map
) * sizeof (location_t
);
2002 for (i
= 0; i
< 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map
); i
+= 2)
2004 if (MACRO_MAP_LOCATIONS (cur_map
)[i
] ==
2005 MACRO_MAP_LOCATIONS (cur_map
)[i
+ 1])
2006 duplicated_macro_maps_locations_size
+=
2007 sizeof (location_t
);
2011 macro_maps_used_size
=
2012 LINEMAPS_MACRO_USED (set
) * sizeof (struct line_map_macro
);
2014 s
->num_ordinary_maps_allocated
= LINEMAPS_ORDINARY_ALLOCATED (set
);
2015 s
->num_ordinary_maps_used
= LINEMAPS_ORDINARY_USED (set
);
2016 s
->ordinary_maps_allocated_size
= ordinary_maps_allocated_size
;
2017 s
->ordinary_maps_used_size
= ordinary_maps_used_size
;
2018 s
->num_expanded_macros
= num_expanded_macros_counter
;
2019 s
->num_macro_tokens
= num_macro_tokens_counter
;
2020 s
->num_macro_maps_used
= LINEMAPS_MACRO_USED (set
);
2021 s
->macro_maps_allocated_size
= macro_maps_allocated_size
;
2022 s
->macro_maps_locations_size
= macro_maps_locations_size
;
2023 s
->macro_maps_used_size
= macro_maps_used_size
;
2024 s
->duplicated_macro_maps_locations_size
=
2025 duplicated_macro_maps_locations_size
;
2026 s
->adhoc_table_size
= (set
->location_adhoc_data_map
.allocated
2027 * sizeof (struct location_adhoc_data
));
2028 s
->adhoc_table_entries_used
= set
->location_adhoc_data_map
.curr_loc
;
2032 /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
2033 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
2034 specifies how many macro maps to dump. */
2037 line_table_dump (FILE *stream
, class line_maps
*set
, unsigned int num_ordinary
,
2038 unsigned int num_macro
)
2048 fprintf (stream
, "# of ordinary maps: %d\n", LINEMAPS_ORDINARY_USED (set
));
2049 fprintf (stream
, "# of macro maps: %d\n", LINEMAPS_MACRO_USED (set
));
2050 fprintf (stream
, "Include stack depth: %d\n", set
->depth
);
2051 fprintf (stream
, "Highest location: %u\n", set
->highest_location
);
2055 fprintf (stream
, "\nOrdinary line maps\n");
2056 for (i
= 0; i
< num_ordinary
&& i
< LINEMAPS_ORDINARY_USED (set
); i
++)
2057 linemap_dump (stream
, set
, i
, false);
2058 fprintf (stream
, "\n");
2063 fprintf (stream
, "\nMacro line maps\n");
2064 for (i
= 0; i
< num_macro
&& i
< LINEMAPS_MACRO_USED (set
); i
++)
2065 linemap_dump (stream
, set
, i
, true);
2066 fprintf (stream
, "\n");
2070 /* class rich_location. */
2072 /* Construct a rich_location with location LOC as its initial range. */
2074 rich_location::rich_location (line_maps
*set
, location_t loc
,
2075 const range_label
*label
) :
2078 m_column_override (0),
2079 m_have_expanded_location (false),
2081 m_seen_impossible_fixit (false),
2082 m_fixits_cannot_be_auto_applied (false),
2085 add_range (loc
, SHOW_RANGE_WITH_CARET
, label
);
2088 /* The destructor for class rich_location. */
2090 rich_location::~rich_location ()
2092 for (unsigned int i
= 0; i
< m_fixit_hints
.count (); i
++)
2093 delete get_fixit_hint (i
);
2096 /* Get location IDX within this rich_location. */
2099 rich_location::get_loc (unsigned int idx
) const
2101 const location_range
*locrange
= get_range (idx
);
2102 return locrange
->m_loc
;
2105 /* Get range IDX within this rich_location. */
2107 const location_range
*
2108 rich_location::get_range (unsigned int idx
) const
2110 return &m_ranges
[idx
];
2113 /* Mutable access to range IDX within this rich_location. */
2116 rich_location::get_range (unsigned int idx
)
2118 return &m_ranges
[idx
];
2121 /* Expand location IDX within this rich_location. */
2122 /* Get an expanded_location for this rich_location's primary
2126 rich_location::get_expanded_location (unsigned int idx
)
2130 /* Cache the expansion of the primary location. */
2131 if (!m_have_expanded_location
)
2134 = linemap_client_expand_location_to_spelling_point
2135 (get_loc (0), LOCATION_ASPECT_CARET
);
2136 if (m_column_override
)
2137 m_expanded_location
.column
= m_column_override
;
2138 m_have_expanded_location
= true;
2141 return m_expanded_location
;
2144 return linemap_client_expand_location_to_spelling_point
2145 (get_loc (idx
), LOCATION_ASPECT_CARET
);
2148 /* Set the column of the primary location, with 0 meaning
2149 "don't override it". */
2152 rich_location::override_column (int column
)
2154 m_column_override
= column
;
2155 m_have_expanded_location
= false;
2158 /* Add the given range. */
2161 rich_location::add_range (location_t loc
,
2162 enum range_display_kind range_display_kind
,
2163 const range_label
*label
)
2165 location_range range
;
2167 range
.m_range_display_kind
= range_display_kind
;
2168 range
.m_label
= label
;
2169 m_ranges
.push (range
);
2172 /* Add or overwrite the location given by IDX, setting its location to LOC,
2173 and setting its m_range_display_kind to RANGE_DISPLAY_KIND.
2175 It must either overwrite an existing location, or add one *exactly* on
2176 the end of the array.
2178 This is primarily for use by gcc when implementing diagnostic format
2180 - the "+" in the C/C++ frontends, for handling format codes like "%q+D"
2181 (which writes the source location of a tree back into location 0 of
2182 the rich_location), and
2183 - the "%C" and "%L" format codes in the Fortran frontend. */
2186 rich_location::set_range (unsigned int idx
, location_t loc
,
2187 enum range_display_kind range_display_kind
)
2189 /* We can either overwrite an existing range, or add one exactly
2190 on the end of the array. */
2191 linemap_assert (idx
<= m_ranges
.count ());
2193 if (idx
== m_ranges
.count ())
2194 add_range (loc
, range_display_kind
);
2197 location_range
*locrange
= get_range (idx
);
2198 locrange
->m_loc
= loc
;
2199 locrange
->m_range_display_kind
= range_display_kind
;
2203 /* Mark any cached value here as dirty. */
2204 m_have_expanded_location
= false;
2207 /* Methods for adding insertion fix-it hints. */
2209 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2210 immediately before the primary range's start location. */
2213 rich_location::add_fixit_insert_before (const char *new_content
)
2215 add_fixit_insert_before (get_loc (), new_content
);
2218 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2219 immediately before the start of WHERE. */
2222 rich_location::add_fixit_insert_before (location_t where
,
2223 const char *new_content
)
2225 location_t start
= get_range_from_loc (m_line_table
, where
).m_start
;
2226 maybe_add_fixit (start
, start
, new_content
);
2229 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2230 immediately after the primary range's end-point. */
2233 rich_location::add_fixit_insert_after (const char *new_content
)
2235 add_fixit_insert_after (get_loc (), new_content
);
2238 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2239 immediately after the end-point of WHERE. */
2242 rich_location::add_fixit_insert_after (location_t where
,
2243 const char *new_content
)
2245 location_t finish
= get_range_from_loc (m_line_table
, where
).m_finish
;
2247 = linemap_position_for_loc_and_offset (m_line_table
, finish
, 1);
2249 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2251 if (next_loc
== finish
)
2253 stop_supporting_fixits ();
2257 maybe_add_fixit (next_loc
, next_loc
, new_content
);
2260 /* Methods for adding removal fix-it hints. */
2262 /* Add a fixit-hint, suggesting removal of the content covered
2266 rich_location::add_fixit_remove ()
2268 add_fixit_remove (get_loc ());
2271 /* Add a fixit-hint, suggesting removal of the content between
2272 the start and finish of WHERE. */
2275 rich_location::add_fixit_remove (location_t where
)
2277 source_range range
= get_range_from_loc (m_line_table
, where
);
2278 add_fixit_remove (range
);
2281 /* Add a fixit-hint, suggesting removal of the content at
2285 rich_location::add_fixit_remove (source_range src_range
)
2287 add_fixit_replace (src_range
, "");
2290 /* Add a fixit-hint, suggesting replacement of the content covered
2291 by range 0 with NEW_CONTENT. */
2294 rich_location::add_fixit_replace (const char *new_content
)
2296 add_fixit_replace (get_loc (), new_content
);
2299 /* Methods for adding "replace" fix-it hints. */
2301 /* Add a fixit-hint, suggesting replacement of the content between
2302 the start and finish of WHERE with NEW_CONTENT. */
2305 rich_location::add_fixit_replace (location_t where
,
2306 const char *new_content
)
2308 source_range range
= get_range_from_loc (m_line_table
, where
);
2309 add_fixit_replace (range
, new_content
);
2312 /* Add a fixit-hint, suggesting replacement of the content at
2313 SRC_RANGE with NEW_CONTENT. */
2316 rich_location::add_fixit_replace (source_range src_range
,
2317 const char *new_content
)
2319 location_t start
= get_pure_location (m_line_table
, src_range
.m_start
);
2320 location_t finish
= get_pure_location (m_line_table
, src_range
.m_finish
);
2322 /* Fix-it hints use half-closed ranges, so attempt to offset the endpoint. */
2324 = linemap_position_for_loc_and_offset (m_line_table
, finish
, 1);
2325 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2327 if (next_loc
== finish
)
2329 stop_supporting_fixits ();
2334 maybe_add_fixit (start
, finish
, new_content
);
2337 /* Get the last fix-it hint within this rich_location, or NULL if none. */
2340 rich_location::get_last_fixit_hint () const
2342 if (m_fixit_hints
.count () > 0)
2343 return get_fixit_hint (m_fixit_hints
.count () - 1);
2348 /* If WHERE is an "awkward" location, then mark this rich_location as not
2349 supporting fixits, purging any thay were already added, and return true.
2351 Otherwise (the common case), return false. */
2354 rich_location::reject_impossible_fixit (location_t where
)
2356 /* Fix-its within a rich_location should either all be suggested, or
2357 none of them should be suggested.
2358 Once we've rejected a fixit, we reject any more, even those
2359 with reasonable locations. */
2360 if (m_seen_impossible_fixit
)
2363 if (where
<= LINE_MAP_MAX_LOCATION_WITH_COLS
)
2364 /* WHERE is a reasonable location for a fix-it; don't reject it. */
2367 /* Otherwise we have an attempt to add a fix-it with an "awkward"
2368 location: either one that we can't obtain column information
2369 for (within an ordinary map), or one within a macro expansion. */
2370 stop_supporting_fixits ();
2374 /* Mark this rich_location as not supporting fixits, purging any that were
2378 rich_location::stop_supporting_fixits ()
2380 m_seen_impossible_fixit
= true;
2382 /* Purge the rich_location of any fix-its that were already added. */
2383 for (unsigned int i
= 0; i
< m_fixit_hints
.count (); i
++)
2384 delete get_fixit_hint (i
);
2385 m_fixit_hints
.truncate (0);
2388 /* Add HINT to the fix-it hints in this rich_location,
2389 consolidating into the prior fixit if possible. */
2392 rich_location::maybe_add_fixit (location_t start
,
2393 location_t next_loc
,
2394 const char *new_content
)
2396 if (reject_impossible_fixit (start
))
2398 if (reject_impossible_fixit (next_loc
))
2401 /* Only allow fix-it hints that affect a single line in one file.
2402 Compare the end-points. */
2403 expanded_location exploc_start
2404 = linemap_client_expand_location_to_spelling_point (start
,
2405 LOCATION_ASPECT_START
);
2406 expanded_location exploc_next_loc
2407 = linemap_client_expand_location_to_spelling_point (next_loc
,
2408 LOCATION_ASPECT_START
);
2409 /* They must be within the same file... */
2410 if (exploc_start
.file
!= exploc_next_loc
.file
)
2412 stop_supporting_fixits ();
2415 /* ...and on the same line. */
2416 if (exploc_start
.line
!= exploc_next_loc
.line
)
2418 stop_supporting_fixits ();
2421 /* The columns must be in the correct order. This can fail if the
2422 endpoints straddle the boundary for which the linemap can represent
2423 columns (PR c/82050). */
2424 if (exploc_start
.column
> exploc_next_loc
.column
)
2426 stop_supporting_fixits ();
2430 const char *newline
= strchr (new_content
, '\n');
2433 /* For now, we can only support insertion of whole lines
2434 i.e. starts at start of line, and the newline is at the end of
2435 the insertion point. */
2437 /* It must be an insertion, not a replacement/deletion. */
2438 if (start
!= next_loc
)
2440 stop_supporting_fixits ();
2444 /* The insertion must be at the start of a line. */
2445 if (exploc_start
.column
!= 1)
2447 stop_supporting_fixits ();
2451 /* The newline must be at end of NEW_CONTENT.
2452 We could eventually split up fix-its at newlines if we wanted
2453 to allow more generality (e.g. to allow adding multiple lines
2454 with one add_fixit call. */
2455 if (newline
[1] != '\0')
2457 stop_supporting_fixits ();
2462 /* Consolidate neighboring fixits.
2463 Don't consolidate into newline-insertion fixits. */
2464 fixit_hint
*prev
= get_last_fixit_hint ();
2465 if (prev
&& !prev
->ends_with_newline_p ())
2466 if (prev
->maybe_append (start
, next_loc
, new_content
))
2469 m_fixit_hints
.push (new fixit_hint (start
, next_loc
, new_content
));
2472 /* class fixit_hint. */
2474 fixit_hint::fixit_hint (location_t start
,
2475 location_t next_loc
,
2476 const char *new_content
)
2478 m_next_loc (next_loc
),
2479 m_bytes (xstrdup (new_content
)),
2480 m_len (strlen (new_content
))
2484 /* Does this fix-it hint affect the given line? */
2487 fixit_hint::affects_line_p (const char *file
, int line
) const
2489 expanded_location exploc_start
2490 = linemap_client_expand_location_to_spelling_point (m_start
,
2491 LOCATION_ASPECT_START
);
2492 if (file
!= exploc_start
.file
)
2494 if (line
< exploc_start
.line
)
2496 expanded_location exploc_next_loc
2497 = linemap_client_expand_location_to_spelling_point (m_next_loc
,
2498 LOCATION_ASPECT_START
);
2499 if (file
!= exploc_next_loc
.file
)
2501 if (line
> exploc_next_loc
.line
)
2506 /* Method for consolidating fix-it hints, for use by
2507 rich_location::maybe_add_fixit.
2508 If possible, merge a pending fix-it hint with the given params
2509 into this one and return true.
2510 Otherwise return false. */
2513 fixit_hint::maybe_append (location_t start
,
2514 location_t next_loc
,
2515 const char *new_content
)
2517 /* For consolidation to be possible, START must be at this hint's
2519 if (start
!= m_next_loc
)
2522 /* If so, we have neighboring replacements; merge them. */
2523 m_next_loc
= next_loc
;
2524 size_t extra_len
= strlen (new_content
);
2525 m_bytes
= (char *)xrealloc (m_bytes
, m_len
+ extra_len
+ 1);
2526 memcpy (m_bytes
+ m_len
, new_content
, extra_len
);
2528 m_bytes
[m_len
] = '\0';
2532 /* Return true iff this hint's content ends with a newline. */
2535 fixit_hint::ends_with_newline_p () const
2539 return m_bytes
[m_len
- 1] == '\n';