1 /* Map (unsigned int) keys to (source file, line, column) triples.
2 Copyright (C) 2001-2018 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 struct line_maps
*, const line_map_ordinary
*);
30 static const line_map_ordinary
* linemap_ordinary_map_lookup (struct line_maps
*,
32 static const line_map_macro
* linemap_macro_map_lookup (struct line_maps
*,
34 static source_location linemap_macro_map_loc_to_def_point
35 (const line_map_macro
*, source_location
);
36 static source_location linemap_macro_map_loc_to_exp_point
37 (const line_map_macro
*, source_location
);
38 static source_location linemap_macro_loc_to_spelling_point
39 (struct line_maps
*, source_location
, const line_map_ordinary
**);
40 static source_location
linemap_macro_loc_to_def_point (struct line_maps
*,
42 const line_map_ordinary
**);
43 static source_location
linemap_macro_loc_to_exp_point (struct 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 (struct 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 source_location, without needing to use an ad-hoc location. */
116 can_be_stored_compactly_p (struct line_maps
*set
,
117 source_location locus
,
118 source_range src_range
,
121 /* If there's an ad-hoc pointer, we can't store it directly in the
122 source_location, 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 source_location 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 (struct line_maps
*set
,
158 source_location locus
,
159 source_range src_range
,
162 struct location_adhoc_data lb
;
163 struct location_adhoc_data
**slot
;
165 if (IS_ADHOC_LOC (locus
))
167 = set
->location_adhoc_data_map
.data
[locus
& MAX_SOURCE_LOCATION
].locus
;
168 if (locus
== 0 && data
== NULL
)
171 /* Any ordinary locations ought to be "pure" at this point: no
172 compressed ranges. */
173 linemap_assert (locus
< RESERVED_LOCATION_COUNT
174 || locus
>= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
175 || locus
>= LINEMAPS_MACRO_LOWEST_LOCATION (set
)
176 || pure_location_p (set
, locus
));
178 /* Consider short-range optimization. */
179 if (can_be_stored_compactly_p (set
, locus
, src_range
, data
))
181 /* The low bits ought to be clear. */
182 linemap_assert (pure_location_p (set
, locus
));
183 const line_map
*map
= linemap_lookup (set
, locus
);
184 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
185 unsigned int int_diff
= src_range
.m_finish
- src_range
.m_start
;
186 unsigned int col_diff
= (int_diff
>> ordmap
->m_range_bits
);
187 if (col_diff
< (1U << ordmap
->m_range_bits
))
189 source_location packed
= locus
| col_diff
;
190 set
->num_optimized_ranges
++;
195 /* We can also compactly store locations
196 when locus == start == finish (and data is NULL). */
197 if (locus
== src_range
.m_start
198 && locus
== src_range
.m_finish
203 set
->num_unoptimized_ranges
++;
206 lb
.src_range
= src_range
;
208 slot
= (struct location_adhoc_data
**)
209 htab_find_slot (set
->location_adhoc_data_map
.htab
, &lb
, INSERT
);
212 if (set
->location_adhoc_data_map
.curr_loc
>=
213 set
->location_adhoc_data_map
.allocated
)
215 char *orig_data
= (char *) set
->location_adhoc_data_map
.data
;
217 /* Cast away extern "C" from the type of xrealloc. */
218 line_map_realloc reallocator
= (set
->reallocator
220 : (line_map_realloc
) xrealloc
);
222 if (set
->location_adhoc_data_map
.allocated
== 0)
223 set
->location_adhoc_data_map
.allocated
= 128;
225 set
->location_adhoc_data_map
.allocated
*= 2;
226 set
->location_adhoc_data_map
.data
= (struct location_adhoc_data
*)
227 reallocator (set
->location_adhoc_data_map
.data
,
228 set
->location_adhoc_data_map
.allocated
229 * sizeof (struct location_adhoc_data
));
230 offset
= (char *) (set
->location_adhoc_data_map
.data
) - orig_data
;
231 if (set
->location_adhoc_data_map
.allocated
> 128)
232 htab_traverse (set
->location_adhoc_data_map
.htab
,
233 location_adhoc_data_update
, &offset
);
235 *slot
= set
->location_adhoc_data_map
.data
236 + set
->location_adhoc_data_map
.curr_loc
;
237 set
->location_adhoc_data_map
.data
[set
->location_adhoc_data_map
.curr_loc
++]
240 return ((*slot
) - set
->location_adhoc_data_map
.data
) | 0x80000000;
243 /* Return the data for the adhoc loc. */
246 get_data_from_adhoc_loc (struct line_maps
*set
, source_location loc
)
248 linemap_assert (IS_ADHOC_LOC (loc
));
249 return set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].data
;
252 /* Return the location for the adhoc loc. */
255 get_location_from_adhoc_loc (struct line_maps
*set
, source_location loc
)
257 linemap_assert (IS_ADHOC_LOC (loc
));
258 return set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
261 /* Return the source_range for adhoc location LOC. */
264 get_range_from_adhoc_loc (struct line_maps
*set
, source_location loc
)
266 linemap_assert (IS_ADHOC_LOC (loc
));
267 return set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].src_range
;
270 /* Get the source_range of location LOC, either from the ad-hoc
271 lookaside table, or embedded inside LOC itself. */
274 get_range_from_loc (struct line_maps
*set
,
277 if (IS_ADHOC_LOC (loc
))
278 return get_range_from_adhoc_loc (set
, loc
);
280 /* For ordinary maps, extract packed range. */
281 if (loc
>= RESERVED_LOCATION_COUNT
282 && loc
< LINEMAPS_MACRO_LOWEST_LOCATION (set
)
283 && loc
<= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
)
285 const line_map
*map
= linemap_lookup (set
, loc
);
286 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
288 int offset
= loc
& ((1 << ordmap
->m_range_bits
) - 1);
289 result
.m_start
= loc
- offset
;
290 result
.m_finish
= result
.m_start
+ (offset
<< ordmap
->m_range_bits
);
294 return source_range::from_location (loc
);
297 /* Get whether location LOC is a "pure" location, or
298 whether it is an ad-hoc location, or embeds range information. */
301 pure_location_p (line_maps
*set
, source_location loc
)
303 if (IS_ADHOC_LOC (loc
))
306 const line_map
*map
= linemap_lookup (set
, loc
);
307 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
309 if (loc
& ((1U << ordmap
->m_range_bits
) - 1))
315 /* Given location LOC within SET, strip away any packed range information
316 or ad-hoc information. */
319 get_pure_location (line_maps
*set
, source_location loc
)
321 if (IS_ADHOC_LOC (loc
))
323 = set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
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 (struct line_maps
*set
,
341 source_location builtin_location
)
343 #if __GNUC__ == 4 && __GNUC_MINOR__ == 2 && !defined (__clang__)
344 /* PR33916, needed to fix PR82939. */
345 memset (set
, 0, sizeof (struct 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 /* Check for and warn about line_maps entered but not exited. */
361 linemap_check_files_exited (struct line_maps
*set
)
363 const line_map_ordinary
*map
;
364 /* Depending upon whether we are handling preprocessed input or
365 not, this can be a user error or an ICE. */
366 for (map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
368 map
= INCLUDED_FROM (set
, map
))
369 fprintf (stderr
, "line-map.c: file \"%s\" entered but not left\n",
370 ORDINARY_MAP_FILE_NAME (map
));
373 /* Create a new line map in the line map set SET, and return it.
374 REASON is the reason of creating the map. It determines the type
375 of map created (ordinary or macro map). Note that ordinary maps and
376 macro maps are allocated in different memory location. */
378 static struct line_map
*
379 new_linemap (struct line_maps
*set
, source_location start_location
)
381 bool macro_p
= start_location
>= LINE_MAP_MAX_LOCATION
;
382 unsigned num_maps_allocated
= LINEMAPS_ALLOCATED (set
, macro_p
);
383 unsigned num_maps_used
= LINEMAPS_USED (set
, macro_p
);
385 if (num_maps_used
== num_maps_allocated
)
387 /* We need more space! */
388 if (!num_maps_allocated
)
389 num_maps_allocated
= 128;
390 num_maps_allocated
*= 2;
392 size_t size_of_a_map
;
396 size_of_a_map
= sizeof (line_map_macro
);
397 buffer
= set
->info_macro
.maps
;
401 size_of_a_map
= sizeof (line_map_ordinary
);
402 buffer
= set
->info_ordinary
.maps
;
405 /* We are going to execute some dance to try to reduce the
406 overhead of the memory allocator, in case we are using the
409 The actual size of memory we are going to get back from the
410 allocator may well be larger than what we ask for. Use this
411 hook to find what that size is. */
413 = set
->round_alloc_size (num_maps_allocated
* size_of_a_map
);
415 /* Now alloc_size contains the exact memory size we would get if
416 we have asked for the initial alloc_size amount of memory.
417 Let's get back to the number of map that amounts to. */
418 unsigned num_maps
= alloc_size
/ size_of_a_map
;
419 buffer
= set
->reallocator (buffer
, num_maps
* size_of_a_map
);
420 memset ((char *)buffer
+ num_maps_used
* size_of_a_map
, 0,
421 (num_maps
- num_maps_used
) * size_of_a_map
);
423 set
->info_macro
.maps
= (line_map_macro
*)buffer
;
425 set
->info_ordinary
.maps
= (line_map_ordinary
*)buffer
;
426 LINEMAPS_ALLOCATED (set
, macro_p
) = num_maps
;
429 line_map
*result
= (macro_p
? (line_map
*)&set
->info_macro
.maps
[num_maps_used
]
430 : (line_map
*)&set
->info_ordinary
.maps
[num_maps_used
]);
431 LINEMAPS_USED (set
, macro_p
)++;
433 result
->start_location
= start_location
;
438 /* Add a mapping of logical source line to physical source file and
441 The text pointed to by TO_FILE must have a lifetime
442 at least as long as the final call to lookup_line (). An empty
443 TO_FILE means standard input. If reason is LC_LEAVE, and
444 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
445 natural values considering the file we are returning to.
447 FROM_LINE should be monotonic increasing across calls to this
448 function. A call to this function can relocate the previous set of
449 maps, so any stored line_map pointers should not be used. */
451 const struct line_map
*
452 linemap_add (struct line_maps
*set
, enum lc_reason reason
,
453 unsigned int sysp
, const char *to_file
, linenum_type to_line
)
455 /* Generate a start_location above the current highest_location.
456 If possible, make the low range bits be zero. */
457 source_location start_location
;
458 if (set
->highest_location
< LINE_MAP_MAX_LOCATION_WITH_COLS
)
460 start_location
= set
->highest_location
+ (1 << set
->default_range_bits
);
461 if (set
->default_range_bits
)
462 start_location
&= ~((1 << set
->default_range_bits
) - 1);
463 linemap_assert (0 == (start_location
464 & ((1 << set
->default_range_bits
) - 1)));
467 start_location
= set
->highest_location
+ 1;
469 linemap_assert (!LINEMAPS_ORDINARY_USED (set
)
471 >= MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set
))));
473 /* When we enter the file for the first time reason cannot be
475 linemap_assert (!(set
->depth
== 0 && reason
== LC_RENAME
));
477 /* If we are leaving the main file, return a NULL map. */
478 if (reason
== LC_LEAVE
479 && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set
))
486 linemap_assert (reason
!= LC_ENTER_MACRO
);
487 line_map_ordinary
*map
488 = linemap_check_ordinary (new_linemap (set
, start_location
));
489 map
->reason
= reason
;
491 if (to_file
&& *to_file
== '\0' && reason
!= LC_RENAME_VERBATIM
)
494 if (reason
== LC_RENAME_VERBATIM
)
497 if (reason
== LC_LEAVE
)
499 /* When we are just leaving an "included" file, and jump to the next
500 location inside the "includer" right after the #include
501 "included", this variable points the map in use right before the
502 #include "included", inside the same "includer" file. */
503 line_map_ordinary
*from
;
505 linemap_assert (!MAIN_FILE_P (map
- 1));
506 /* (MAP - 1) points to the map we are leaving. The
507 map from which (MAP - 1) got included should be the map
508 that comes right before MAP in the same file. */
509 from
= INCLUDED_FROM (set
, map
- 1);
511 /* A TO_FILE of NULL is special - we use the natural values. */
514 to_file
= ORDINARY_MAP_FILE_NAME (from
);
515 to_line
= SOURCE_LINE (from
, from
[1].start_location
);
516 sysp
= ORDINARY_MAP_IN_SYSTEM_HEADER_P (from
);
519 linemap_assert (filename_cmp (ORDINARY_MAP_FILE_NAME (from
),
524 map
->to_file
= to_file
;
525 map
->to_line
= to_line
;
526 LINEMAPS_ORDINARY_CACHE (set
) = LINEMAPS_ORDINARY_USED (set
) - 1;
527 map
->m_column_and_range_bits
= 0;
528 map
->m_range_bits
= 0;
529 set
->highest_location
= start_location
;
530 set
->highest_line
= start_location
;
531 set
->max_column_hint
= 0;
533 /* This assertion is placed after set->highest_location has
534 been updated, since the latter affects
535 linemap_location_from_macro_expansion_p, which ultimately affects
537 linemap_assert (pure_location_p (set
, start_location
));
539 if (reason
== LC_ENTER
)
542 set
->depth
== 0 ? -1 : (int) (LINEMAPS_ORDINARY_USED (set
) - 2);
544 if (set
->trace_includes
)
545 trace_include (set
, map
);
547 else if (reason
== LC_RENAME
)
548 map
->included_from
= ORDINARY_MAP_INCLUDER_FILE_INDEX (&map
[-1]);
549 else if (reason
== LC_LEAVE
)
553 ORDINARY_MAP_INCLUDER_FILE_INDEX (INCLUDED_FROM (set
, map
- 1));
559 /* Returns TRUE if the line table set tracks token locations across
560 macro expansion, FALSE otherwise. */
563 linemap_tracks_macro_expansion_locs_p (struct line_maps
*set
)
565 return LINEMAPS_MACRO_MAPS (set
) != NULL
;
568 /* Create a macro map. A macro map encodes source locations of tokens
569 that are part of a macro replacement-list, at a macro expansion
570 point. See the extensive comments of struct line_map and struct
571 line_map_macro, in line-map.h.
573 This map shall be created when the macro is expanded. The map
574 encodes the source location of the expansion point of the macro as
575 well as the "original" source location of each token that is part
576 of the macro replacement-list. If a macro is defined but never
577 expanded, it has no macro map. SET is the set of maps the macro
578 map should be part of. MACRO_NODE is the macro which the new macro
579 map should encode source locations for. EXPANSION is the location
580 of the expansion point of MACRO. For function-like macros
581 invocations, it's best to make it point to the closing parenthesis
582 of the macro, rather than the the location of the first character
583 of the macro. NUM_TOKENS is the number of tokens that are part of
584 the replacement-list of MACRO.
586 Note that when we run out of the integer space available for source
587 locations, this function returns NULL. In that case, callers of
588 this function cannot encode {line,column} pairs into locations of
589 macro tokens anymore. */
591 const line_map_macro
*
592 linemap_enter_macro (struct line_maps
*set
, struct cpp_hashnode
*macro_node
,
593 source_location expansion
, unsigned int num_tokens
)
596 source_location start_location
;
597 /* Cast away extern "C" from the type of xrealloc. */
598 line_map_realloc reallocator
= (set
->reallocator
600 : (line_map_realloc
) xrealloc
);
602 start_location
= LINEMAPS_MACRO_LOWEST_LOCATION (set
) - num_tokens
;
604 if (start_location
< LINE_MAP_MAX_LOCATION
)
605 /* We ran out of macro map space. */
608 map
= linemap_check_macro (new_linemap (set
, start_location
));
610 map
->macro
= macro_node
;
611 map
->n_tokens
= num_tokens
;
613 = (source_location
*) reallocator (NULL
,
615 * sizeof (source_location
));
616 map
->expansion
= expansion
;
617 memset (MACRO_MAP_LOCATIONS (map
), 0,
618 num_tokens
* sizeof (source_location
));
620 LINEMAPS_MACRO_CACHE (set
) = LINEMAPS_MACRO_USED (set
) - 1;
625 /* Create and return a virtual location for a token that is part of a
626 macro expansion-list at a macro expansion point. See the comment
627 inside struct line_map_macro to see what an expansion-list exactly
630 A call to this function must come after a call to
633 MAP is the map into which the source location is created. TOKEN_NO
634 is the index of the token in the macro replacement-list, starting
637 ORIG_LOC is the location of the token outside of this macro
638 expansion. If the token comes originally from the macro
639 definition, it is the locus in the macro definition; otherwise it
640 is a location in the context of the caller of this macro expansion
641 (which is a virtual location or a source location if the caller is
642 itself a macro expansion or not).
644 ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition,
645 either of the token itself or of a macro parameter that it
649 linemap_add_macro_token (const line_map_macro
*map
,
650 unsigned int token_no
,
651 source_location orig_loc
,
652 source_location orig_parm_replacement_loc
)
654 source_location result
;
656 linemap_assert (linemap_macro_expansion_map_p (map
));
657 linemap_assert (token_no
< MACRO_MAP_NUM_MACRO_TOKENS (map
));
659 MACRO_MAP_LOCATIONS (map
)[2 * token_no
] = orig_loc
;
660 MACRO_MAP_LOCATIONS (map
)[2 * token_no
+ 1] = orig_parm_replacement_loc
;
662 result
= MAP_START_LOCATION (map
) + token_no
;
666 /* Return a source_location for the start (i.e. column==0) of
667 (physical) line TO_LINE in the current source file (as in the
668 most recent linemap_add). MAX_COLUMN_HINT is the highest column
669 number we expect to use in this line (but it does not change
670 the highest_location). */
673 linemap_line_start (struct line_maps
*set
, linenum_type to_line
,
674 unsigned int max_column_hint
)
676 line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
677 source_location highest
= set
->highest_location
;
679 linenum_type last_line
=
680 SOURCE_LINE (map
, set
->highest_line
);
681 int line_delta
= to_line
- last_line
;
682 bool add_map
= false;
683 linemap_assert (map
->m_column_and_range_bits
>= map
->m_range_bits
);
684 int effective_column_bits
= map
->m_column_and_range_bits
- map
->m_range_bits
;
688 && line_delta
* map
->m_column_and_range_bits
> 1000)
689 || (max_column_hint
>= (1U << effective_column_bits
))
690 || (max_column_hint
<= 80 && effective_column_bits
>= 10)
691 || (highest
> LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
692 && map
->m_range_bits
> 0)
693 || (highest
> LINE_MAP_MAX_LOCATION_WITH_COLS
694 && (set
->max_column_hint
|| highest
>= LINE_MAP_MAX_LOCATION
)))
697 max_column_hint
= set
->max_column_hint
;
702 if (max_column_hint
> LINE_MAP_MAX_COLUMN_NUMBER
703 || highest
> LINE_MAP_MAX_LOCATION_WITH_COLS
)
705 /* If the column number is ridiculous or we've allocated a huge
706 number of source_locations, give up on column numbers
707 (and on packed ranges). */
711 if (highest
>= LINE_MAP_MAX_LOCATION
)
717 if (highest
<= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
)
718 range_bits
= set
->default_range_bits
;
721 while (max_column_hint
>= (1U << column_bits
))
723 max_column_hint
= 1U << column_bits
;
724 column_bits
+= range_bits
;
726 /* Allocate the new line_map. However, if the current map only has a
727 single line we can sometimes just increase its column_bits instead. */
729 || last_line
!= ORDINARY_MAP_STARTING_LINE_NUMBER (map
)
730 || SOURCE_COLUMN (map
, highest
) >= (1U << (column_bits
- range_bits
))
731 || range_bits
< map
->m_range_bits
)
732 map
= linemap_check_ordinary
733 (const_cast <line_map
*>
734 (linemap_add (set
, LC_RENAME
,
735 ORDINARY_MAP_IN_SYSTEM_HEADER_P (map
),
736 ORDINARY_MAP_FILE_NAME (map
),
738 map
->m_column_and_range_bits
= column_bits
;
739 map
->m_range_bits
= range_bits
;
740 r
= (MAP_START_LOCATION (map
)
741 + ((to_line
- ORDINARY_MAP_STARTING_LINE_NUMBER (map
))
745 r
= set
->highest_line
+ (line_delta
<< map
->m_column_and_range_bits
);
747 /* Locations of ordinary tokens are always lower than locations of
749 if (r
>= LINE_MAP_MAX_LOCATION
)
752 set
->highest_line
= r
;
753 if (r
> set
->highest_location
)
754 set
->highest_location
= r
;
755 set
->max_column_hint
= max_column_hint
;
757 /* At this point, we expect one of:
758 (a) the normal case: a "pure" location with 0 range bits, or
759 (b) we've gone past LINE_MAP_MAX_LOCATION_WITH_COLS so can't track
760 columns anymore (or ranges), or
761 (c) we're in a region with a column hint exceeding
762 LINE_MAP_MAX_COLUMN_NUMBER, so column-tracking is off,
763 with column_bits == 0. */
764 linemap_assert (pure_location_p (set
, r
)
765 || r
>= LINE_MAP_MAX_LOCATION_WITH_COLS
766 || map
->m_column_and_range_bits
== 0);
767 linemap_assert (SOURCE_LINE (map
, r
) == to_line
);
771 /* Encode and return a source_location from a column number. The
772 source line considered is the last source line used to call
773 linemap_line_start, i.e, the last source line which a location was
777 linemap_position_for_column (struct line_maps
*set
, unsigned int to_column
)
779 source_location r
= set
->highest_line
;
782 (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set
)));
784 if (to_column
>= set
->max_column_hint
)
786 if (r
> LINE_MAP_MAX_LOCATION_WITH_COLS
787 || to_column
> LINE_MAP_MAX_COLUMN_NUMBER
)
789 /* Running low on source_locations - disable column numbers. */
794 /* Otherwise, attempt to start a new line that can hold TO_COLUMN,
795 with some space to spare. This may or may not lead to a new
796 linemap being created. */
797 line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
798 r
= linemap_line_start (set
, SOURCE_LINE (map
, r
), to_column
+ 50);
799 map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
800 if (map
->m_column_and_range_bits
== 0)
802 /* ...then the linemap has column-tracking disabled,
803 presumably due to exceeding either
804 LINE_MAP_MAX_LOCATION_WITH_COLS (overall) or
805 LINE_MAP_MAX_COLUMN_NUMBER (within this line).
806 Return the start of the linemap, which encodes column 0, for
812 line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (set
);
813 r
= r
+ (to_column
<< map
->m_range_bits
);
814 if (r
>= set
->highest_location
)
815 set
->highest_location
= r
;
819 /* Encode and return a source location from a given line and
823 linemap_position_for_line_and_column (line_maps
*set
,
824 const line_map_ordinary
*ord_map
,
828 linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map
) <= line
);
830 source_location r
= MAP_START_LOCATION (ord_map
);
831 r
+= ((line
- ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map
))
832 << ord_map
->m_column_and_range_bits
);
833 if (r
<= LINE_MAP_MAX_LOCATION_WITH_COLS
)
834 r
+= ((column
& ((1 << ord_map
->m_column_and_range_bits
) - 1))
835 << ord_map
->m_range_bits
);
836 source_location upper_limit
= LINEMAPS_MACRO_LOWEST_LOCATION (set
);
837 if (r
>= upper_limit
)
839 if (r
> set
->highest_location
)
840 set
->highest_location
= r
;
844 /* Encode and return a source_location starting from location LOC and
845 shifting it by COLUMN_OFFSET columns. This function does not support
846 virtual locations. */
849 linemap_position_for_loc_and_offset (struct line_maps
*set
,
851 unsigned int column_offset
)
853 const line_map_ordinary
* map
= NULL
;
855 if (IS_ADHOC_LOC (loc
))
856 loc
= set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
858 /* This function does not support virtual locations yet. */
859 if (linemap_location_from_macro_expansion_p (set
, loc
))
862 if (column_offset
== 0
863 /* Adding an offset to a reserved location (like
864 UNKNOWN_LOCATION for the C/C++ FEs) does not really make
865 sense. So let's leave the location intact in that case. */
866 || loc
< RESERVED_LOCATION_COUNT
)
869 /* We find the real location and shift it. */
870 loc
= linemap_resolve_location (set
, loc
, LRK_SPELLING_LOCATION
, &map
);
871 /* The new location (loc + offset) should be higher than the first
872 location encoded by MAP. This can fail if the line information
873 is messed up because of line directives (see PR66415). */
874 if (MAP_START_LOCATION (map
) >= loc
+ (column_offset
<< map
->m_range_bits
))
877 linenum_type line
= SOURCE_LINE (map
, loc
);
878 unsigned int column
= SOURCE_COLUMN (map
, loc
);
880 /* If MAP is not the last line map of its set, then the new location
881 (loc + offset) should be less than the first location encoded by
882 the next line map of the set. Otherwise, we try to encode the
883 location in the next map. */
884 while (map
!= LINEMAPS_LAST_ORDINARY_MAP (set
)
885 && (loc
+ (column_offset
<< map
->m_range_bits
)
886 >= MAP_START_LOCATION (&map
[1])))
889 /* If the next map starts in a higher line, we cannot encode the
891 if (line
< ORDINARY_MAP_STARTING_LINE_NUMBER (map
))
895 column
+= column_offset
;
897 /* Bail out if the column is not representable within the existing
899 if (column
>= (1u << (map
->m_column_and_range_bits
- map
->m_range_bits
)))
903 linemap_position_for_line_and_column (set
, map
, line
, column
);
904 if (linemap_assert_fails (r
<= set
->highest_location
)
905 || linemap_assert_fails (map
== linemap_lookup (set
, r
)))
911 /* Given a virtual source location yielded by a map (either an
912 ordinary or a macro map), returns that map. */
914 const struct line_map
*
915 linemap_lookup (struct line_maps
*set
, source_location line
)
917 if (IS_ADHOC_LOC (line
))
918 line
= set
->location_adhoc_data_map
.data
[line
& MAX_SOURCE_LOCATION
].locus
;
919 if (linemap_location_from_macro_expansion_p (set
, line
))
920 return linemap_macro_map_lookup (set
, line
);
921 return linemap_ordinary_map_lookup (set
, line
);
924 /* Given a source location yielded by an ordinary map, returns that
925 map. Since the set is built chronologically, the logical lines are
926 monotonic increasing, and so the list is sorted and we can use a
929 static const line_map_ordinary
*
930 linemap_ordinary_map_lookup (struct line_maps
*set
, source_location line
)
932 unsigned int md
, mn
, mx
;
933 const line_map_ordinary
*cached
, *result
;
935 if (IS_ADHOC_LOC (line
))
936 line
= set
->location_adhoc_data_map
.data
[line
& MAX_SOURCE_LOCATION
].locus
;
938 if (set
== NULL
|| line
< RESERVED_LOCATION_COUNT
)
941 mn
= LINEMAPS_ORDINARY_CACHE (set
);
942 mx
= LINEMAPS_ORDINARY_USED (set
);
944 cached
= LINEMAPS_ORDINARY_MAP_AT (set
, mn
);
945 /* We should get a segfault if no line_maps have been added yet. */
946 if (line
>= MAP_START_LOCATION (cached
))
948 if (mn
+ 1 == mx
|| line
< MAP_START_LOCATION (&cached
[1]))
960 if (MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (set
, md
)) > line
)
966 LINEMAPS_ORDINARY_CACHE (set
) = mn
;
967 result
= LINEMAPS_ORDINARY_MAP_AT (set
, mn
);
968 linemap_assert (line
>= MAP_START_LOCATION (result
));
972 /* Given a source location yielded by a macro map, returns that map.
973 Since the set is built chronologically, the logical lines are
974 monotonic decreasing, and so the list is sorted and we can use a
977 static const line_map_macro
*
978 linemap_macro_map_lookup (struct line_maps
*set
, source_location line
)
980 unsigned int md
, mn
, mx
;
981 const struct line_map_macro
*cached
, *result
;
983 if (IS_ADHOC_LOC (line
))
984 line
= set
->location_adhoc_data_map
.data
[line
& MAX_SOURCE_LOCATION
].locus
;
986 linemap_assert (line
>= LINEMAPS_MACRO_LOWEST_LOCATION (set
));
991 mn
= LINEMAPS_MACRO_CACHE (set
);
992 mx
= LINEMAPS_MACRO_USED (set
);
993 cached
= LINEMAPS_MACRO_MAP_AT (set
, mn
);
995 if (line
>= MAP_START_LOCATION (cached
))
997 if (mn
== 0 || line
< MAP_START_LOCATION (&cached
[-1]))
1006 if (MAP_START_LOCATION (LINEMAPS_MACRO_MAP_AT (set
, md
)) > line
)
1012 LINEMAPS_MACRO_CACHE (set
) = mx
;
1013 result
= LINEMAPS_MACRO_MAP_AT (set
, LINEMAPS_MACRO_CACHE (set
));
1014 linemap_assert (MAP_START_LOCATION (result
) <= line
);
1019 /* Return TRUE if MAP encodes locations coming from a macro
1020 replacement-list at macro expansion point. */
1023 linemap_macro_expansion_map_p (const struct line_map
*map
)
1025 return map
&& !MAP_ORDINARY_P (map
);
1028 /* If LOCATION is the locus of a token in a replacement-list of a
1029 macro expansion return the location of the macro expansion point.
1031 Read the comments of struct line_map and struct line_map_macro in
1032 line-map.h to understand what a macro expansion point is. */
1034 static source_location
1035 linemap_macro_map_loc_to_exp_point (const line_map_macro
*map
,
1036 source_location location ATTRIBUTE_UNUSED
)
1038 linemap_assert (linemap_macro_expansion_map_p (map
)
1039 && location
>= MAP_START_LOCATION (map
));
1041 /* Make sure LOCATION is correct. */
1042 linemap_assert ((location
- MAP_START_LOCATION (map
))
1043 < MACRO_MAP_NUM_MACRO_TOKENS (map
));
1045 return MACRO_MAP_EXPANSION_POINT_LOCATION (map
);
1048 /* LOCATION is the source location of a token that belongs to a macro
1049 replacement-list as part of the macro expansion denoted by MAP.
1051 Return the location of the token at the definition point of the
1054 static source_location
1055 linemap_macro_map_loc_to_def_point (const line_map_macro
*map
,
1056 source_location location
)
1060 linemap_assert (linemap_macro_expansion_map_p (map
)
1061 && location
>= MAP_START_LOCATION (map
));
1062 linemap_assert (location
>= RESERVED_LOCATION_COUNT
);
1064 token_no
= location
- MAP_START_LOCATION (map
);
1065 linemap_assert (token_no
< MACRO_MAP_NUM_MACRO_TOKENS (map
));
1067 location
= MACRO_MAP_LOCATIONS (map
)[2 * token_no
+ 1];
1072 /* If LOCATION is the locus of a token that is an argument of a
1073 function-like macro M and appears in the expansion of M, return the
1074 locus of that argument in the context of the caller of M.
1076 In other words, this returns the xI location presented in the
1077 comments of line_map_macro above. */
1079 linemap_macro_map_loc_unwind_toward_spelling (line_maps
*set
,
1080 const line_map_macro
* map
,
1081 source_location location
)
1085 if (IS_ADHOC_LOC (location
))
1086 location
= get_location_from_adhoc_loc (set
, location
);
1088 linemap_assert (linemap_macro_expansion_map_p (map
)
1089 && location
>= MAP_START_LOCATION (map
));
1090 linemap_assert (location
>= RESERVED_LOCATION_COUNT
);
1091 linemap_assert (!IS_ADHOC_LOC (location
));
1093 token_no
= location
- MAP_START_LOCATION (map
);
1094 linemap_assert (token_no
< MACRO_MAP_NUM_MACRO_TOKENS (map
));
1096 location
= MACRO_MAP_LOCATIONS (map
)[2 * token_no
];
1101 /* Return the source line number corresponding to source location
1102 LOCATION. SET is the line map set LOCATION comes from. If
1103 LOCATION is the source location of token that is part of the
1104 replacement-list of a macro expansion return the line number of the
1105 macro expansion point. */
1108 linemap_get_expansion_line (struct line_maps
*set
,
1109 source_location location
)
1111 const line_map_ordinary
*map
= NULL
;
1113 if (IS_ADHOC_LOC (location
))
1114 location
= set
->location_adhoc_data_map
.data
[location
1115 & MAX_SOURCE_LOCATION
].locus
;
1117 if (location
< RESERVED_LOCATION_COUNT
)
1121 linemap_macro_loc_to_exp_point (set
, location
, &map
);
1123 return SOURCE_LINE (map
, location
);
1126 /* Return the path of the file corresponding to source code location
1129 If LOCATION is the source location of token that is part of the
1130 replacement-list of a macro expansion return the file path of the
1131 macro expansion point.
1133 SET is the line map set LOCATION comes from. */
1136 linemap_get_expansion_filename (struct line_maps
*set
,
1137 source_location location
)
1139 const struct line_map_ordinary
*map
= NULL
;
1141 if (IS_ADHOC_LOC (location
))
1142 location
= set
->location_adhoc_data_map
.data
[location
1143 & MAX_SOURCE_LOCATION
].locus
;
1145 if (location
< RESERVED_LOCATION_COUNT
)
1149 linemap_macro_loc_to_exp_point (set
, location
, &map
);
1151 return LINEMAP_FILE (map
);
1154 /* Return the name of the macro associated to MACRO_MAP. */
1157 linemap_map_get_macro_name (const line_map_macro
*macro_map
)
1159 linemap_assert (macro_map
&& linemap_macro_expansion_map_p (macro_map
));
1160 return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map
));
1163 /* Return a positive value if LOCATION is the locus of a token that is
1164 located in a system header, O otherwise. It returns 1 if LOCATION
1165 is the locus of a token that is located in a system header, and 2
1166 if LOCATION is the locus of a token located in a C system header
1167 that therefore needs to be extern "C" protected in C++.
1169 Note that this function returns 1 if LOCATION belongs to a token
1170 that is part of a macro replacement-list defined in a system
1171 header, but expanded in a non-system file. */
1174 linemap_location_in_system_header_p (struct line_maps
*set
,
1175 source_location location
)
1177 const struct line_map
*map
= NULL
;
1179 if (IS_ADHOC_LOC (location
))
1180 location
= set
->location_adhoc_data_map
.data
[location
1181 & MAX_SOURCE_LOCATION
].locus
;
1183 if (location
< RESERVED_LOCATION_COUNT
)
1186 /* Let's look at where the token for LOCATION comes from. */
1189 map
= linemap_lookup (set
, location
);
1192 if (!linemap_macro_expansion_map_p (map
))
1193 /* It's a normal token. */
1194 return LINEMAP_SYSP (linemap_check_ordinary (map
));
1197 const line_map_macro
*macro_map
= linemap_check_macro (map
);
1199 /* It's a token resulting from a macro expansion. */
1200 source_location loc
=
1201 linemap_macro_map_loc_unwind_toward_spelling (set
, macro_map
, location
);
1202 if (loc
< RESERVED_LOCATION_COUNT
)
1203 /* This token might come from a built-in macro. Let's
1204 look at where that macro got expanded. */
1205 location
= linemap_macro_map_loc_to_exp_point (macro_map
, location
);
1216 /* Return TRUE if LOCATION is a source code location of a token that is part of
1217 a macro expansion, FALSE otherwise. */
1220 linemap_location_from_macro_expansion_p (const struct line_maps
*set
,
1221 source_location location
)
1223 if (IS_ADHOC_LOC (location
))
1224 location
= set
->location_adhoc_data_map
.data
[location
1225 & MAX_SOURCE_LOCATION
].locus
;
1227 return location
>= LINE_MAP_MAX_LOCATION
;
1230 /* Given two virtual locations *LOC0 and *LOC1, return the first
1231 common macro map in their macro expansion histories. Return NULL
1232 if no common macro was found. *LOC0 (resp. *LOC1) is set to the
1233 virtual location of the token inside the resulting macro. */
1235 static const struct line_map
*
1236 first_map_in_common_1 (struct line_maps
*set
,
1237 source_location
*loc0
,
1238 source_location
*loc1
)
1240 source_location l0
= *loc0
, l1
= *loc1
;
1241 const struct line_map
*map0
= linemap_lookup (set
, l0
),
1242 *map1
= linemap_lookup (set
, l1
);
1244 while (linemap_macro_expansion_map_p (map0
)
1245 && linemap_macro_expansion_map_p (map1
)
1248 if (MAP_START_LOCATION (map0
) < MAP_START_LOCATION (map1
))
1250 l0
= linemap_macro_map_loc_to_exp_point (linemap_check_macro (map0
),
1252 map0
= linemap_lookup (set
, l0
);
1256 l1
= linemap_macro_map_loc_to_exp_point (linemap_check_macro (map1
),
1258 map1
= linemap_lookup (set
, l1
);
1271 /* Given two virtual locations LOC0 and LOC1, return the first common
1272 macro map in their macro expansion histories. Return NULL if no
1273 common macro was found. *RES_LOC0 (resp. *RES_LOC1) is set to the
1274 virtual location of the token inside the resulting macro, upon
1275 return of a non-NULL result. */
1277 static const struct line_map
*
1278 first_map_in_common (struct line_maps
*set
,
1279 source_location loc0
,
1280 source_location loc1
,
1281 source_location
*res_loc0
,
1282 source_location
*res_loc1
)
1287 return first_map_in_common_1 (set
, res_loc0
, res_loc1
);
1290 /* Return a positive value if PRE denotes the location of a token that
1291 comes before the token of POST, 0 if PRE denotes the location of
1292 the same token as the token for POST, and a negative value
1296 linemap_compare_locations (struct line_maps
*set
,
1297 source_location pre
,
1298 source_location post
)
1300 bool pre_virtual_p
, post_virtual_p
;
1301 source_location l0
= pre
, l1
= post
;
1303 if (IS_ADHOC_LOC (l0
))
1304 l0
= get_location_from_adhoc_loc (set
, l0
);
1305 if (IS_ADHOC_LOC (l1
))
1306 l1
= get_location_from_adhoc_loc (set
, l1
);
1311 if ((pre_virtual_p
= linemap_location_from_macro_expansion_p (set
, l0
)))
1312 l0
= linemap_resolve_location (set
, l0
,
1313 LRK_MACRO_EXPANSION_POINT
,
1316 if ((post_virtual_p
= linemap_location_from_macro_expansion_p (set
, l1
)))
1317 l1
= linemap_resolve_location (set
, l1
,
1318 LRK_MACRO_EXPANSION_POINT
,
1325 /* So pre and post represent two tokens that are present in a
1326 same macro expansion. Let's see if the token for pre was
1327 before the token for post in that expansion. */
1329 const struct line_map
*map
=
1330 first_map_in_common (set
, pre
, post
, &l0
, &l1
);
1333 /* This should not be possible. */
1336 i0
= l0
- MAP_START_LOCATION (map
);
1337 i1
= l1
- MAP_START_LOCATION (map
);
1341 if (IS_ADHOC_LOC (l0
))
1342 l0
= get_location_from_adhoc_loc (set
, l0
);
1343 if (IS_ADHOC_LOC (l1
))
1344 l1
= get_location_from_adhoc_loc (set
, l1
);
1349 /* Print an include trace, for e.g. the -H option of the preprocessor. */
1352 trace_include (const struct line_maps
*set
, const line_map_ordinary
*map
)
1354 unsigned int i
= set
->depth
;
1359 fprintf (stderr
, " %s\n", ORDINARY_MAP_FILE_NAME (map
));
1362 /* Return the spelling location of the token wherever it comes from,
1363 whether part of a macro definition or not.
1365 This is a subroutine for linemap_resolve_location. */
1367 static source_location
1368 linemap_macro_loc_to_spelling_point (struct line_maps
*set
,
1369 source_location location
,
1370 const line_map_ordinary
**original_map
)
1372 linemap_assert (set
&& location
>= RESERVED_LOCATION_COUNT
);
1376 const struct line_map
*map
= linemap_lookup (set
, location
);
1377 if (!map
|| MAP_ORDINARY_P (map
))
1380 *original_map
= (const line_map_ordinary
*)map
;
1384 location
= linemap_macro_map_loc_unwind_toward_spelling
1385 (set
, linemap_check_macro (map
), location
);
1391 /* If LOCATION is the source location of a token that belongs to a
1392 macro replacement-list -- as part of a macro expansion -- then
1393 return the location of the token at the definition point of the
1394 macro. Otherwise, return LOCATION. SET is the set of maps
1395 location come from. ORIGINAL_MAP is an output parm. If non NULL,
1396 the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
1397 returned location comes from.
1399 This is a subroutine of linemap_resolve_location. */
1401 static source_location
1402 linemap_macro_loc_to_def_point (struct line_maps
*set
,
1403 source_location location
,
1404 const line_map_ordinary
**original_map
)
1406 linemap_assert (set
&& location
>= RESERVED_LOCATION_COUNT
);
1410 source_location caret_loc
= location
;
1411 if (IS_ADHOC_LOC (caret_loc
))
1412 caret_loc
= get_location_from_adhoc_loc (set
, caret_loc
);
1414 const line_map
*map
= linemap_lookup (set
, caret_loc
);
1415 if (!map
|| MAP_ORDINARY_P (map
))
1418 *original_map
= (const line_map_ordinary
*)map
;
1422 location
= linemap_macro_map_loc_to_def_point
1423 (linemap_check_macro (map
), caret_loc
);
1429 /* If LOCATION is the source location of a token that belongs to a
1430 macro replacement-list -- at a macro expansion point -- then return
1431 the location of the topmost expansion point of the macro. We say
1432 topmost because if we are in the context of a nested macro
1433 expansion, the function returns the source location of the first
1434 macro expansion that triggered the nested expansions.
1436 Otherwise, return LOCATION. SET is the set of maps location come
1437 from. ORIGINAL_MAP is an output parm. If non NULL, the function
1438 sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
1439 location comes from.
1441 This is a subroutine of linemap_resolve_location. */
1443 static source_location
1444 linemap_macro_loc_to_exp_point (struct line_maps
*set
,
1445 source_location location
,
1446 const line_map_ordinary
**original_map
)
1448 struct line_map
*map
;
1450 if (IS_ADHOC_LOC (location
))
1451 location
= set
->location_adhoc_data_map
.data
[location
1452 & MAX_SOURCE_LOCATION
].locus
;
1454 linemap_assert (set
&& location
>= RESERVED_LOCATION_COUNT
);
1458 map
= const_cast <line_map
*> (linemap_lookup (set
, location
));
1459 if (!linemap_macro_expansion_map_p (map
))
1461 location
= linemap_macro_map_loc_to_exp_point (linemap_check_macro (map
),
1466 *original_map
= linemap_check_ordinary (map
);
1470 /* Resolve a virtual location into either a spelling location, an
1471 expansion point location or a token argument replacement point
1472 location. Return the map that encodes the virtual location as well
1473 as the resolved location.
1475 If LOC is *NOT* the location of a token resulting from the
1476 expansion of a macro, then the parameter LRK (which stands for
1477 Location Resolution Kind) is ignored and the resulting location
1478 just equals the one given in argument.
1480 Now if LOC *IS* the location of a token resulting from the
1481 expansion of a macro, this is what happens.
1483 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1484 -------------------------------
1486 The virtual location is resolved to the first macro expansion point
1487 that led to this macro expansion.
1489 * If LRK is set to LRK_SPELLING_LOCATION
1490 -------------------------------------
1492 The virtual location is resolved to the locus where the token has
1493 been spelled in the source. This can follow through all the macro
1494 expansions that led to the token.
1496 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1497 --------------------------------------
1499 The virtual location is resolved to the locus of the token in the
1500 context of the macro definition.
1502 If LOC is the locus of a token that is an argument of a
1503 function-like macro [replacing a parameter in the replacement list
1504 of the macro] the virtual location is resolved to the locus of the
1505 parameter that is replaced, in the context of the definition of the
1508 If LOC is the locus of a token that is not an argument of a
1509 function-like macro, then the function behaves as if LRK was set to
1510 LRK_SPELLING_LOCATION.
1512 If MAP is not NULL, *MAP is set to the map encoding the
1513 returned location. Note that if the returned location wasn't originally
1514 encoded by a map, then *MAP is set to NULL. This can happen if LOC
1515 resolves to a location reserved for the client code, like
1516 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1519 linemap_resolve_location (struct line_maps
*set
,
1520 source_location loc
,
1521 enum location_resolution_kind lrk
,
1522 const line_map_ordinary
**map
)
1524 source_location locus
= loc
;
1525 if (IS_ADHOC_LOC (loc
))
1526 locus
= set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
1528 if (locus
< RESERVED_LOCATION_COUNT
)
1530 /* A reserved location wasn't encoded in a map. Let's return a
1531 NULL map here, just like what linemap_ordinary_map_lookup
1540 case LRK_MACRO_EXPANSION_POINT
:
1541 loc
= linemap_macro_loc_to_exp_point (set
, loc
, map
);
1543 case LRK_SPELLING_LOCATION
:
1544 loc
= linemap_macro_loc_to_spelling_point (set
, loc
, map
);
1546 case LRK_MACRO_DEFINITION_LOCATION
:
1547 loc
= linemap_macro_loc_to_def_point (set
, loc
, map
);
1555 /* TRUE if LOCATION is a source code location of a token that is part of the
1556 definition of a macro, FALSE otherwise. */
1559 linemap_location_from_macro_definition_p (struct line_maps
*set
,
1560 source_location loc
)
1562 if (IS_ADHOC_LOC (loc
))
1563 loc
= get_location_from_adhoc_loc (set
, loc
);
1565 if (!linemap_location_from_macro_expansion_p (set
, loc
))
1570 const struct line_map_macro
*map
1571 = linemap_check_macro (linemap_lookup (set
, loc
));
1573 source_location s_loc
1574 = linemap_macro_map_loc_unwind_toward_spelling (set
, map
, loc
);
1575 if (linemap_location_from_macro_expansion_p (set
, s_loc
))
1579 source_location def_loc
1580 = linemap_macro_map_loc_to_def_point (map
, loc
);
1581 return s_loc
== def_loc
;
1587 Suppose that LOC is the virtual location of a token T coming from
1588 the expansion of a macro M. This function then steps up to get the
1589 location L of the point where M got expanded. If L is a spelling
1590 location inside a macro expansion M', then this function returns
1591 the locus of the point where M' was expanded. Said otherwise, this
1592 function returns the location of T in the context that triggered
1595 *LOC_MAP must be set to the map of LOC. This function then sets it
1596 to the map of the returned location. */
1599 linemap_unwind_toward_expansion (struct line_maps
*set
,
1600 source_location loc
,
1601 const struct line_map
**map
)
1603 source_location resolved_location
;
1604 const line_map_macro
*macro_map
= linemap_check_macro (*map
);
1605 const struct line_map
*resolved_map
;
1607 if (IS_ADHOC_LOC (loc
))
1608 loc
= set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
1611 linemap_macro_map_loc_unwind_toward_spelling (set
, macro_map
, loc
);
1612 resolved_map
= linemap_lookup (set
, resolved_location
);
1614 if (!linemap_macro_expansion_map_p (resolved_map
))
1616 resolved_location
= linemap_macro_map_loc_to_exp_point (macro_map
, loc
);
1617 resolved_map
= linemap_lookup (set
, resolved_location
);
1620 *map
= resolved_map
;
1621 return resolved_location
;
1624 /* If LOC is the virtual location of a token coming from the expansion
1625 of a macro M and if its spelling location is reserved (e.g, a
1626 location for a built-in token), then this function unwinds (using
1627 linemap_unwind_toward_expansion) the location until a location that
1628 is not reserved and is not in a system header is reached. In other
1629 words, this unwinds the reserved location until a location that is
1630 in real source code is reached.
1632 Otherwise, if the spelling location for LOC is not reserved or if
1633 LOC doesn't come from the expansion of a macro, the function
1634 returns LOC as is and *MAP is not touched.
1636 *MAP is set to the map of the returned location if the later is
1637 different from LOC. */
1639 linemap_unwind_to_first_non_reserved_loc (struct line_maps
*set
,
1640 source_location loc
,
1641 const struct line_map
**map
)
1643 source_location resolved_loc
;
1644 const struct line_map
*map0
= NULL
;
1645 const line_map_ordinary
*map1
= NULL
;
1647 if (IS_ADHOC_LOC (loc
))
1648 loc
= set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
1650 map0
= linemap_lookup (set
, loc
);
1651 if (!linemap_macro_expansion_map_p (map0
))
1654 resolved_loc
= linemap_resolve_location (set
, loc
,
1655 LRK_SPELLING_LOCATION
,
1658 if (resolved_loc
>= RESERVED_LOCATION_COUNT
1659 && !LINEMAP_SYSP (map1
))
1662 while (linemap_macro_expansion_map_p (map0
)
1663 && (resolved_loc
< RESERVED_LOCATION_COUNT
1664 || LINEMAP_SYSP (map1
)))
1666 loc
= linemap_unwind_toward_expansion (set
, loc
, &map0
);
1667 resolved_loc
= linemap_resolve_location (set
, loc
,
1668 LRK_SPELLING_LOCATION
,
1677 /* Expand source code location LOC and return a user readable source
1678 code location. LOC must be a spelling (non-virtual) location. If
1679 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1680 location is returned. */
1683 linemap_expand_location (struct line_maps
*set
,
1684 const struct line_map
*map
,
1685 source_location loc
)
1688 expanded_location xloc
;
1690 memset (&xloc
, 0, sizeof (xloc
));
1691 if (IS_ADHOC_LOC (loc
))
1694 = set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].data
;
1695 loc
= set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
1698 if (loc
< RESERVED_LOCATION_COUNT
)
1699 /* The location for this token wasn't generated from a line map.
1700 It was probably a location for a builtin token, chosen by some
1701 client code. Let's not try to expand the location in that
1703 else if (map
== NULL
)
1704 /* We shouldn't be getting a NULL map with a location that is not
1705 reserved by the client code. */
1709 /* MAP must be an ordinary map and LOC must be non-virtual,
1710 encoded into this map, obviously; the accessors used on MAP
1711 below ensure it is ordinary. Let's just assert the
1712 non-virtualness of LOC here. */
1713 if (linemap_location_from_macro_expansion_p (set
, loc
))
1716 const line_map_ordinary
*ord_map
= linemap_check_ordinary (map
);
1718 xloc
.file
= LINEMAP_FILE (ord_map
);
1719 xloc
.line
= SOURCE_LINE (ord_map
, loc
);
1720 xloc
.column
= SOURCE_COLUMN (ord_map
, loc
);
1721 xloc
.sysp
= LINEMAP_SYSP (ord_map
) != 0;
1728 /* Dump line map at index IX in line table SET to STREAM. If STREAM
1729 is NULL, use stderr. IS_MACRO is true if the caller wants to
1730 dump a macro map, false otherwise. */
1733 linemap_dump (FILE *stream
, struct line_maps
*set
, unsigned ix
, bool is_macro
)
1735 const char *const lc_reasons_v
[LC_HWM
]
1736 = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
1738 const line_map
*map
;
1746 map
= LINEMAPS_ORDINARY_MAP_AT (set
, ix
);
1747 reason
= linemap_check_ordinary (map
)->reason
;
1751 map
= LINEMAPS_MACRO_MAP_AT (set
, ix
);
1752 reason
= LC_ENTER_MACRO
;
1755 fprintf (stream
, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
1756 ix
, (void *) map
, map
->start_location
,
1757 reason
< LC_HWM
? lc_reasons_v
[reason
] : "???",
1759 && ORDINARY_MAP_IN_SYSTEM_HEADER_P (linemap_check_ordinary (map
)))
1763 const line_map_ordinary
*ord_map
= linemap_check_ordinary (map
);
1764 unsigned includer_ix
;
1765 const line_map_ordinary
*includer_map
;
1767 includer_ix
= ORDINARY_MAP_INCLUDER_FILE_INDEX (ord_map
);
1768 includer_map
= includer_ix
< LINEMAPS_ORDINARY_USED (set
)
1769 ? LINEMAPS_ORDINARY_MAP_AT (set
, includer_ix
)
1772 fprintf (stream
, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map
),
1773 ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map
));
1774 fprintf (stream
, "Included from: [%d] %s\n", includer_ix
,
1775 includer_map
? ORDINARY_MAP_FILE_NAME (includer_map
) : "None");
1779 const line_map_macro
*macro_map
= linemap_check_macro (map
);
1780 fprintf (stream
, "Macro: %s (%u tokens)\n",
1781 linemap_map_get_macro_name (macro_map
),
1782 MACRO_MAP_NUM_MACRO_TOKENS (macro_map
));
1785 fprintf (stream
, "\n");
1789 /* Dump debugging information about source location LOC into the file
1790 stream STREAM. SET is the line map set LOC comes from. */
1793 linemap_dump_location (struct line_maps
*set
,
1794 source_location loc
,
1797 const line_map_ordinary
*map
;
1798 source_location location
;
1799 const char *path
= "", *from
= "";
1800 int l
= -1, c
= -1, s
= -1, e
= -1;
1802 if (IS_ADHOC_LOC (loc
))
1803 loc
= set
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
1809 linemap_resolve_location (set
, loc
, LRK_MACRO_DEFINITION_LOCATION
, &map
);
1812 /* Only reserved locations can be tolerated in this case. */
1813 linemap_assert (location
< RESERVED_LOCATION_COUNT
);
1816 path
= LINEMAP_FILE (map
);
1817 l
= SOURCE_LINE (map
, location
);
1818 c
= SOURCE_COLUMN (map
, location
);
1819 s
= LINEMAP_SYSP (map
) != 0;
1820 e
= location
!= loc
;
1824 from
= (INCLUDED_FROM (set
, map
))
1825 ? LINEMAP_FILE (INCLUDED_FROM (set
, map
))
1829 /* P: path, L: line, C: column, S: in-system-header, M: map address,
1830 E: macro expansion?, LOC: original location, R: resolved location */
1831 fprintf (stream
, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}",
1832 path
, from
, l
, c
, s
, (void*)map
, e
, loc
, location
);
1835 /* Return the highest location emitted for a given file for which
1836 there is a line map in SET. FILE_NAME is the file name to
1837 consider. If the function returns TRUE, *LOC is set to the highest
1838 location emitted for that file. */
1841 linemap_get_file_highest_location (struct line_maps
*set
,
1842 const char *file_name
,
1843 source_location
*loc
)
1845 /* If the set is empty or no ordinary map has been created then
1846 there is no file to look for ... */
1847 if (set
== NULL
|| set
->info_ordinary
.used
== 0)
1850 /* Now look for the last ordinary map created for FILE_NAME. */
1852 for (i
= set
->info_ordinary
.used
- 1; i
>= 0; --i
)
1854 const char *fname
= set
->info_ordinary
.maps
[i
].to_file
;
1855 if (fname
&& !filename_cmp (fname
, file_name
))
1862 /* The highest location for a given map is either the starting
1863 location of the next map minus one, or -- if the map is the
1864 latest one -- the highest location of the set. */
1865 source_location result
;
1866 if (i
== (int) set
->info_ordinary
.used
- 1)
1867 result
= set
->highest_location
;
1869 result
= set
->info_ordinary
.maps
[i
+ 1].start_location
- 1;
1875 /* Compute and return statistics about the memory consumption of some
1876 parts of the line table SET. */
1879 linemap_get_statistics (struct line_maps
*set
,
1880 struct linemap_stats
*s
)
1882 long ordinary_maps_allocated_size
, ordinary_maps_used_size
,
1883 macro_maps_allocated_size
, macro_maps_used_size
,
1884 macro_maps_locations_size
= 0, duplicated_macro_maps_locations_size
= 0;
1886 const line_map_macro
*cur_map
;
1888 ordinary_maps_allocated_size
=
1889 LINEMAPS_ORDINARY_ALLOCATED (set
) * sizeof (struct line_map_ordinary
);
1891 ordinary_maps_used_size
=
1892 LINEMAPS_ORDINARY_USED (set
) * sizeof (struct line_map_ordinary
);
1894 macro_maps_allocated_size
=
1895 LINEMAPS_MACRO_ALLOCATED (set
) * sizeof (struct line_map_macro
);
1897 for (cur_map
= LINEMAPS_MACRO_MAPS (set
);
1898 cur_map
&& cur_map
<= LINEMAPS_LAST_MACRO_MAP (set
);
1903 linemap_assert (linemap_macro_expansion_map_p (cur_map
));
1905 macro_maps_locations_size
+=
1906 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map
) * sizeof (source_location
);
1908 for (i
= 0; i
< 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map
); i
+= 2)
1910 if (MACRO_MAP_LOCATIONS (cur_map
)[i
] ==
1911 MACRO_MAP_LOCATIONS (cur_map
)[i
+ 1])
1912 duplicated_macro_maps_locations_size
+=
1913 sizeof (source_location
);
1917 macro_maps_used_size
=
1918 LINEMAPS_MACRO_USED (set
) * sizeof (struct line_map_macro
);
1920 s
->num_ordinary_maps_allocated
= LINEMAPS_ORDINARY_ALLOCATED (set
);
1921 s
->num_ordinary_maps_used
= LINEMAPS_ORDINARY_USED (set
);
1922 s
->ordinary_maps_allocated_size
= ordinary_maps_allocated_size
;
1923 s
->ordinary_maps_used_size
= ordinary_maps_used_size
;
1924 s
->num_expanded_macros
= num_expanded_macros_counter
;
1925 s
->num_macro_tokens
= num_macro_tokens_counter
;
1926 s
->num_macro_maps_used
= LINEMAPS_MACRO_USED (set
);
1927 s
->macro_maps_allocated_size
= macro_maps_allocated_size
;
1928 s
->macro_maps_locations_size
= macro_maps_locations_size
;
1929 s
->macro_maps_used_size
= macro_maps_used_size
;
1930 s
->duplicated_macro_maps_locations_size
=
1931 duplicated_macro_maps_locations_size
;
1932 s
->adhoc_table_size
= (set
->location_adhoc_data_map
.allocated
1933 * sizeof (struct location_adhoc_data
));
1934 s
->adhoc_table_entries_used
= set
->location_adhoc_data_map
.curr_loc
;
1938 /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
1939 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
1940 specifies how many macro maps to dump. */
1943 line_table_dump (FILE *stream
, struct line_maps
*set
, unsigned int num_ordinary
,
1944 unsigned int num_macro
)
1954 fprintf (stream
, "# of ordinary maps: %d\n", LINEMAPS_ORDINARY_USED (set
));
1955 fprintf (stream
, "# of macro maps: %d\n", LINEMAPS_MACRO_USED (set
));
1956 fprintf (stream
, "Include stack depth: %d\n", set
->depth
);
1957 fprintf (stream
, "Highest location: %u\n", set
->highest_location
);
1961 fprintf (stream
, "\nOrdinary line maps\n");
1962 for (i
= 0; i
< num_ordinary
&& i
< LINEMAPS_ORDINARY_USED (set
); i
++)
1963 linemap_dump (stream
, set
, i
, false);
1964 fprintf (stream
, "\n");
1969 fprintf (stream
, "\nMacro line maps\n");
1970 for (i
= 0; i
< num_macro
&& i
< LINEMAPS_MACRO_USED (set
); i
++)
1971 linemap_dump (stream
, set
, i
, true);
1972 fprintf (stream
, "\n");
1976 /* class rich_location. */
1978 /* Construct a rich_location with location LOC as its initial range. */
1980 rich_location::rich_location (line_maps
*set
, source_location loc
) :
1983 m_column_override (0),
1984 m_have_expanded_location (false),
1986 m_seen_impossible_fixit (false),
1987 m_fixits_cannot_be_auto_applied (false)
1989 add_range (loc
, true);
1992 /* The destructor for class rich_location. */
1994 rich_location::~rich_location ()
1996 for (unsigned int i
= 0; i
< m_fixit_hints
.count (); i
++)
1997 delete get_fixit_hint (i
);
2000 /* Get location IDX within this rich_location. */
2003 rich_location::get_loc (unsigned int idx
) const
2005 const location_range
*locrange
= get_range (idx
);
2006 return locrange
->m_loc
;
2009 /* Get range IDX within this rich_location. */
2011 const location_range
*
2012 rich_location::get_range (unsigned int idx
) const
2014 return &m_ranges
[idx
];
2017 /* Mutable access to range IDX within this rich_location. */
2020 rich_location::get_range (unsigned int idx
)
2022 return &m_ranges
[idx
];
2025 /* Expand location IDX within this rich_location. */
2026 /* Get an expanded_location for this rich_location's primary
2030 rich_location::get_expanded_location (unsigned int idx
)
2034 /* Cache the expansion of the primary location. */
2035 if (!m_have_expanded_location
)
2038 = linemap_client_expand_location_to_spelling_point
2039 (get_loc (0), LOCATION_ASPECT_CARET
);
2040 if (m_column_override
)
2041 m_expanded_location
.column
= m_column_override
;
2042 m_have_expanded_location
= true;
2045 return m_expanded_location
;
2048 return linemap_client_expand_location_to_spelling_point
2049 (get_loc (idx
), LOCATION_ASPECT_CARET
);
2052 /* Set the column of the primary location, with 0 meaning
2053 "don't override it". */
2056 rich_location::override_column (int column
)
2058 m_column_override
= column
;
2059 m_have_expanded_location
= false;
2062 /* Add the given range. */
2065 rich_location::add_range (source_location loc
, bool show_caret_p
)
2067 location_range range
;
2069 range
.m_show_caret_p
= show_caret_p
;
2070 m_ranges
.push (range
);
2073 /* Add or overwrite the location given by IDX, setting its location to LOC,
2074 and setting its "should my caret be printed" flag to SHOW_CARET_P.
2076 It must either overwrite an existing location, or add one *exactly* on
2077 the end of the array.
2079 This is primarily for use by gcc when implementing diagnostic format
2081 - the "+" in the C/C++ frontends, for handling format codes like "%q+D"
2082 (which writes the source location of a tree back into location 0 of
2083 the rich_location), and
2084 - the "%C" and "%L" format codes in the Fortran frontend. */
2087 rich_location::set_range (unsigned int idx
, source_location loc
,
2090 /* We can either overwrite an existing range, or add one exactly
2091 on the end of the array. */
2092 linemap_assert (idx
<= m_ranges
.count ());
2094 if (idx
== m_ranges
.count ())
2095 add_range (loc
, show_caret_p
);
2098 location_range
*locrange
= get_range (idx
);
2099 locrange
->m_loc
= loc
;
2100 locrange
->m_show_caret_p
= show_caret_p
;
2104 /* Mark any cached value here as dirty. */
2105 m_have_expanded_location
= false;
2108 /* Methods for adding insertion fix-it hints. */
2110 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2111 immediately before the primary range's start location. */
2114 rich_location::add_fixit_insert_before (const char *new_content
)
2116 add_fixit_insert_before (get_loc (), new_content
);
2119 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2120 immediately before the start of WHERE. */
2123 rich_location::add_fixit_insert_before (source_location where
,
2124 const char *new_content
)
2126 source_location start
= get_range_from_loc (m_line_table
, where
).m_start
;
2127 maybe_add_fixit (start
, start
, new_content
);
2130 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2131 immediately after the primary range's end-point. */
2134 rich_location::add_fixit_insert_after (const char *new_content
)
2136 add_fixit_insert_after (get_loc (), new_content
);
2139 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2140 immediately after the end-point of WHERE. */
2143 rich_location::add_fixit_insert_after (source_location where
,
2144 const char *new_content
)
2146 source_location finish
= get_range_from_loc (m_line_table
, where
).m_finish
;
2147 source_location next_loc
2148 = linemap_position_for_loc_and_offset (m_line_table
, finish
, 1);
2150 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2152 if (next_loc
== finish
)
2154 stop_supporting_fixits ();
2158 maybe_add_fixit (next_loc
, next_loc
, new_content
);
2161 /* Methods for adding removal fix-it hints. */
2163 /* Add a fixit-hint, suggesting removal of the content covered
2167 rich_location::add_fixit_remove ()
2169 add_fixit_remove (get_loc ());
2172 /* Add a fixit-hint, suggesting removal of the content between
2173 the start and finish of WHERE. */
2176 rich_location::add_fixit_remove (source_location where
)
2178 source_range range
= get_range_from_loc (m_line_table
, where
);
2179 add_fixit_remove (range
);
2182 /* Add a fixit-hint, suggesting removal of the content at
2186 rich_location::add_fixit_remove (source_range src_range
)
2188 add_fixit_replace (src_range
, "");
2191 /* Add a fixit-hint, suggesting replacement of the content covered
2192 by range 0 with NEW_CONTENT. */
2195 rich_location::add_fixit_replace (const char *new_content
)
2197 add_fixit_replace (get_loc (), new_content
);
2200 /* Methods for adding "replace" fix-it hints. */
2202 /* Add a fixit-hint, suggesting replacement of the content between
2203 the start and finish of WHERE with NEW_CONTENT. */
2206 rich_location::add_fixit_replace (source_location where
,
2207 const char *new_content
)
2209 source_range range
= get_range_from_loc (m_line_table
, where
);
2210 add_fixit_replace (range
, new_content
);
2213 /* Add a fixit-hint, suggesting replacement of the content at
2214 SRC_RANGE with NEW_CONTENT. */
2217 rich_location::add_fixit_replace (source_range src_range
,
2218 const char *new_content
)
2220 source_location start
= get_pure_location (m_line_table
, src_range
.m_start
);
2221 source_location finish
= get_pure_location (m_line_table
, src_range
.m_finish
);
2223 /* Fix-it hints use half-closed ranges, so attempt to offset the endpoint. */
2224 source_location next_loc
2225 = linemap_position_for_loc_and_offset (m_line_table
, finish
, 1);
2226 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2228 if (next_loc
== finish
)
2230 stop_supporting_fixits ();
2235 maybe_add_fixit (start
, finish
, new_content
);
2238 /* Get the last fix-it hint within this rich_location, or NULL if none. */
2241 rich_location::get_last_fixit_hint () const
2243 if (m_fixit_hints
.count () > 0)
2244 return get_fixit_hint (m_fixit_hints
.count () - 1);
2249 /* If WHERE is an "awkward" location, then mark this rich_location as not
2250 supporting fixits, purging any thay were already added, and return true.
2252 Otherwise (the common case), return false. */
2255 rich_location::reject_impossible_fixit (source_location where
)
2257 /* Fix-its within a rich_location should either all be suggested, or
2258 none of them should be suggested.
2259 Once we've rejected a fixit, we reject any more, even those
2260 with reasonable locations. */
2261 if (m_seen_impossible_fixit
)
2264 if (where
<= LINE_MAP_MAX_LOCATION_WITH_COLS
)
2265 /* WHERE is a reasonable location for a fix-it; don't reject it. */
2268 /* Otherwise we have an attempt to add a fix-it with an "awkward"
2269 location: either one that we can't obtain column information
2270 for (within an ordinary map), or one within a macro expansion. */
2271 stop_supporting_fixits ();
2275 /* Mark this rich_location as not supporting fixits, purging any that were
2279 rich_location::stop_supporting_fixits ()
2281 m_seen_impossible_fixit
= true;
2283 /* Purge the rich_location of any fix-its that were already added. */
2284 for (unsigned int i
= 0; i
< m_fixit_hints
.count (); i
++)
2285 delete get_fixit_hint (i
);
2286 m_fixit_hints
.truncate (0);
2289 /* Add HINT to the fix-it hints in this rich_location,
2290 consolidating into the prior fixit if possible. */
2293 rich_location::maybe_add_fixit (source_location start
,
2294 source_location next_loc
,
2295 const char *new_content
)
2297 if (reject_impossible_fixit (start
))
2299 if (reject_impossible_fixit (next_loc
))
2302 /* Only allow fix-it hints that affect a single line in one file.
2303 Compare the end-points. */
2304 expanded_location exploc_start
2305 = linemap_client_expand_location_to_spelling_point (start
,
2306 LOCATION_ASPECT_START
);
2307 expanded_location exploc_next_loc
2308 = linemap_client_expand_location_to_spelling_point (next_loc
,
2309 LOCATION_ASPECT_START
);
2310 /* They must be within the same file... */
2311 if (exploc_start
.file
!= exploc_next_loc
.file
)
2313 stop_supporting_fixits ();
2316 /* ...and on the same line. */
2317 if (exploc_start
.line
!= exploc_next_loc
.line
)
2319 stop_supporting_fixits ();
2322 /* The columns must be in the correct order. This can fail if the
2323 endpoints straddle the boundary for which the linemap can represent
2324 columns (PR c/82050). */
2325 if (exploc_start
.column
> exploc_next_loc
.column
)
2327 stop_supporting_fixits ();
2331 const char *newline
= strchr (new_content
, '\n');
2334 /* For now, we can only support insertion of whole lines
2335 i.e. starts at start of line, and the newline is at the end of
2336 the insertion point. */
2338 /* It must be an insertion, not a replacement/deletion. */
2339 if (start
!= next_loc
)
2341 stop_supporting_fixits ();
2345 /* The insertion must be at the start of a line. */
2346 if (exploc_start
.column
!= 1)
2348 stop_supporting_fixits ();
2352 /* The newline must be at end of NEW_CONTENT.
2353 We could eventually split up fix-its at newlines if we wanted
2354 to allow more generality (e.g. to allow adding multiple lines
2355 with one add_fixit call. */
2356 if (newline
[1] != '\0')
2358 stop_supporting_fixits ();
2363 /* Consolidate neighboring fixits.
2364 Don't consolidate into newline-insertion fixits. */
2365 fixit_hint
*prev
= get_last_fixit_hint ();
2366 if (prev
&& !prev
->ends_with_newline_p ())
2367 if (prev
->maybe_append (start
, next_loc
, new_content
))
2370 m_fixit_hints
.push (new fixit_hint (start
, next_loc
, new_content
));
2373 /* class fixit_hint. */
2375 fixit_hint::fixit_hint (source_location start
,
2376 source_location next_loc
,
2377 const char *new_content
)
2379 m_next_loc (next_loc
),
2380 m_bytes (xstrdup (new_content
)),
2381 m_len (strlen (new_content
))
2385 /* Does this fix-it hint affect the given line? */
2388 fixit_hint::affects_line_p (const char *file
, int line
) const
2390 expanded_location exploc_start
2391 = linemap_client_expand_location_to_spelling_point (m_start
,
2392 LOCATION_ASPECT_START
);
2393 if (file
!= exploc_start
.file
)
2395 if (line
< exploc_start
.line
)
2397 expanded_location exploc_next_loc
2398 = linemap_client_expand_location_to_spelling_point (m_next_loc
,
2399 LOCATION_ASPECT_START
);
2400 if (file
!= exploc_next_loc
.file
)
2402 if (line
> exploc_next_loc
.line
)
2407 /* Method for consolidating fix-it hints, for use by
2408 rich_location::maybe_add_fixit.
2409 If possible, merge a pending fix-it hint with the given params
2410 into this one and return true.
2411 Otherwise return false. */
2414 fixit_hint::maybe_append (source_location start
,
2415 source_location next_loc
,
2416 const char *new_content
)
2418 /* For consolidation to be possible, START must be at this hint's
2420 if (start
!= m_next_loc
)
2423 /* If so, we have neighboring replacements; merge them. */
2424 m_next_loc
= next_loc
;
2425 size_t extra_len
= strlen (new_content
);
2426 m_bytes
= (char *)xrealloc (m_bytes
, m_len
+ extra_len
+ 1);
2427 memcpy (m_bytes
+ m_len
, new_content
, extra_len
);
2429 m_bytes
[m_len
] = '\0';
2433 /* Return true iff this hint's content ends with a newline. */
2436 fixit_hint::ends_with_newline_p () const
2440 return m_bytes
[m_len
- 1] == '\n';