Daily bump.
[official-gcc.git] / libcpp / line-map.c
blob1957dd712c82921748935436688f904d2cd1dec5
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
7 later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; see the file COPYING3. If not see
16 <http://www.gnu.org/licenses/>.
18 In other words, you are welcome to use, share and improve this program.
19 You are forbidden to forbid anyone else to use, share and improve
20 what you give them. Help stamp out software-hoarding! */
22 #include "config.h"
23 #include "system.h"
24 #include "line-map.h"
25 #include "cpplib.h"
26 #include "internal.h"
27 #include "hashtab.h"
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 *,
31 location_t);
32 static const line_map_macro* linemap_macro_map_lookup (const line_maps *,
33 location_t);
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 *,
41 location_t,
42 const line_map_ordinary **);
43 static location_t linemap_macro_loc_to_exp_point (line_maps *,
44 location_t,
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. */
62 static hashval_t
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
70 + (size_t) lb->data);
73 /* Compare function for location_adhoc_data hashtable. */
75 static int
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. */
90 static int
91 location_adhoc_data_update (void **slot, void *data)
93 *((char **) slot)
94 = (char *) ((uintptr_t) *((char **) slot) + *((ptrdiff_t *) data));
95 return 1;
98 /* Rebuild the hash table from the location adhoc data. */
100 void
101 rebuild_location_adhoc_htab (line_maps *set)
103 unsigned i;
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. */
115 static bool
116 can_be_stored_compactly_p (line_maps *set,
117 location_t locus,
118 source_range src_range,
119 void *data)
121 /* If there's an ad-hoc pointer, we can't store it directly in the
122 location_t, we need the lookaside. */
123 if (data)
124 return false;
126 /* We only store ranges that begin at the locus and that are sufficiently
127 "sane". */
128 if (src_range.m_start != locus)
129 return false;
131 if (src_range.m_finish < src_range.m_start)
132 return false;
134 if (src_range.m_start < RESERVED_LOCATION_COUNT)
135 return false;
137 if (locus >= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
138 return false;
140 /* All 3 locations must be within ordinary maps, typically, the same
141 ordinary map. */
142 location_t lowest_macro_loc = LINEMAPS_MACRO_LOWEST_LOCATION (set);
143 if (locus >= lowest_macro_loc)
144 return false;
145 if (src_range.m_start >= lowest_macro_loc)
146 return false;
147 if (src_range.m_finish >= lowest_macro_loc)
148 return false;
150 /* Passed all tests. */
151 return true;
154 /* Combine LOCUS and DATA to a combined adhoc loc. */
156 location_t
157 get_combined_adhoc_loc (line_maps *set,
158 location_t locus,
159 source_range src_range,
160 void *data)
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)
168 return 0;
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++;
190 return packed;
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
198 && !data)
199 return locus;
201 if (!data)
202 set->num_unoptimized_ranges++;
204 lb.locus = locus;
205 lb.src_range = src_range;
206 lb.data = data;
207 slot = (struct location_adhoc_data **)
208 htab_find_slot (set->location_adhoc_data_map.htab, &lb, INSERT);
209 if (*slot == NULL)
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;
215 ptrdiff_t offset;
216 /* Cast away extern "C" from the type of xrealloc. */
217 line_map_realloc reallocator = (set->reallocator
218 ? set->reallocator
219 : (line_map_realloc) xrealloc);
221 if (set->location_adhoc_data_map.allocated == 0)
222 set->location_adhoc_data_map.allocated = 128;
223 else
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++]
237 = lb;
239 return ((*slot) - set->location_adhoc_data_map.data) | 0x80000000;
242 /* Return the data for the adhoc loc. */
244 void *
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. */
253 location_t
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. */
262 static source_range
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. */
272 source_range
273 get_range_from_loc (line_maps *set,
274 location_t loc)
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);
286 source_range result;
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);
290 return result;
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. */
299 bool
300 pure_location_p (line_maps *set, location_t loc)
302 if (IS_ADHOC_LOC (loc))
303 return false;
305 const line_map *map = linemap_lookup (set, loc);
306 if (map == NULL)
307 return true;
308 const line_map_ordinary *ordmap = linemap_check_ordinary (map);
310 if (loc & ((1U << ordmap->m_range_bits) - 1))
311 return false;
313 return true;
316 /* Given location LOC within SET, strip away any packed range information
317 or ad-hoc information. */
319 location_t
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))
326 return loc;
328 if (loc < RESERVED_LOCATION_COUNT)
329 return loc;
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. */
339 void
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));
346 #else
347 new (set) line_maps();
348 #endif
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. */
369 void
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);
375 ! MAIN_FILE_P (map);
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. */
383 line_map *
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;
399 void *buffer;
400 if (macro_p)
402 size_of_a_map = sizeof (line_map_macro);
403 buffer = set->info_macro.maps;
405 else
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
413 ggc-page.c one.
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. */
418 size_t alloc_size
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);
428 if (macro_p)
429 set->info_macro.maps = (line_map_macro *)buffer;
430 else
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;
439 return result;
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;
456 return result;
459 /* Return the location of the last source line within an ordinary
460 map. */
461 inline location_t
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
471 line number.
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)
497 || (start_location
498 >= MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set))));
500 /* When we enter the file for the first time reason cannot be
501 LC_RENAME. */
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))
507 && to_file == NULL)
509 set->depth--;
510 return NULL;
513 linemap_assert (reason != LC_ENTER_MACRO);
515 if (start_location >= LINE_MAP_MAX_LOCATION)
516 /* We ran out of line map space. */
517 start_location = 0;
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)
524 to_file = "<stdin>";
526 if (reason == LC_RENAME_VERBATIM)
527 reason = LC_RENAME;
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. */
544 if (to_file == NULL)
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);
550 else
551 linemap_assert (filename_cmp (ORDINARY_MAP_FILE_NAME (from),
552 to_file) == 0);
555 map->sysp = sysp;
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
569 pure_location_p. */
570 linemap_assert (pure_location_p (set, start_location));
572 if (reason == LC_ENTER)
574 if (set->depth == 0)
575 map->included_from = 0;
576 else
577 /* The location of the end of the just-closed map. */
578 map->included_from
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);
582 set->depth++;
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)
590 set->depth--;
591 map->included_from = linemap_included_from (from);
594 return map;
597 /* Create a location for a module NAME imported at FROM. */
599 location_t
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);
608 return loc;
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. */
616 void
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. Return the start location
625 of the new map, or 0 if failed (because we ran out of locations. */
627 unsigned
628 linemap_module_restore (line_maps *set, unsigned lwm)
630 linemap_assert (lwm);
632 const line_map_ordinary *pre_map
633 = linemap_check_ordinary (LINEMAPS_MAP_AT (set, false, lwm - 1));
634 unsigned src_line = SOURCE_LINE (pre_map, 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))))
642 /* linemap_add will think we were included from the same as the preceeding
643 map. */
644 const_cast <line_map_ordinary *> (post_map)->included_from = inc_at;
646 return post_map->start_location;
649 return 0;
652 /* Returns TRUE if the line table set tracks token locations across
653 macro expansion, FALSE otherwise. */
655 bool
656 linemap_tracks_macro_expansion_locs_p (line_maps *set)
658 return LINEMAPS_MACRO_MAPS (set) != NULL;
661 /* Create a macro map. A macro map encodes source locations of tokens
662 that are part of a macro replacement-list, at a macro expansion
663 point. See the extensive comments of struct line_map and struct
664 line_map_macro, in line-map.h.
666 This map shall be created when the macro is expanded. The map
667 encodes the source location of the expansion point of the macro as
668 well as the "original" source location of each token that is part
669 of the macro replacement-list. If a macro is defined but never
670 expanded, it has no macro map. SET is the set of maps the macro
671 map should be part of. MACRO_NODE is the macro which the new macro
672 map should encode source locations for. EXPANSION is the location
673 of the expansion point of MACRO. For function-like macros
674 invocations, it's best to make it point to the closing parenthesis
675 of the macro, rather than the the location of the first character
676 of the macro. NUM_TOKENS is the number of tokens that are part of
677 the replacement-list of MACRO.
679 Note that when we run out of the integer space available for source
680 locations, this function returns NULL. In that case, callers of
681 this function cannot encode {line,column} pairs into locations of
682 macro tokens anymore. */
684 const line_map_macro *
685 linemap_enter_macro (class line_maps *set, struct cpp_hashnode *macro_node,
686 location_t expansion, unsigned int num_tokens)
688 location_t start_location
689 = LINEMAPS_MACRO_LOWEST_LOCATION (set) - num_tokens;
691 if (start_location < LINE_MAP_MAX_LOCATION)
692 /* We ran out of macro map space. */
693 return NULL;
695 line_map_macro *map = linemap_check_macro (new_linemap (set, start_location));
697 map->macro = macro_node;
698 map->n_tokens = num_tokens;
699 map->macro_locations
700 = (location_t*) set->reallocator (NULL,
701 2 * num_tokens
702 * sizeof (location_t));
703 map->expansion = expansion;
704 memset (MACRO_MAP_LOCATIONS (map), 0,
705 2 * num_tokens * sizeof (location_t));
707 LINEMAPS_MACRO_CACHE (set) = LINEMAPS_MACRO_USED (set) - 1;
709 return map;
712 /* Create and return a virtual location for a token that is part of a
713 macro expansion-list at a macro expansion point. See the comment
714 inside struct line_map_macro to see what an expansion-list exactly
717 A call to this function must come after a call to
718 linemap_enter_macro.
720 MAP is the map into which the source location is created. TOKEN_NO
721 is the index of the token in the macro replacement-list, starting
722 at number 0.
724 ORIG_LOC is the location of the token outside of this macro
725 expansion. If the token comes originally from the macro
726 definition, it is the locus in the macro definition; otherwise it
727 is a location in the context of the caller of this macro expansion
728 (which is a virtual location or a source location if the caller is
729 itself a macro expansion or not).
731 ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition,
732 either of the token itself or of a macro parameter that it
733 replaces. */
735 location_t
736 linemap_add_macro_token (const line_map_macro *map,
737 unsigned int token_no,
738 location_t orig_loc,
739 location_t orig_parm_replacement_loc)
741 location_t result;
743 linemap_assert (linemap_macro_expansion_map_p (map));
744 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
746 MACRO_MAP_LOCATIONS (map)[2 * token_no] = orig_loc;
747 MACRO_MAP_LOCATIONS (map)[2 * token_no + 1] = orig_parm_replacement_loc;
749 result = MAP_START_LOCATION (map) + token_no;
750 return result;
753 /* Return a location_t for the start (i.e. column==0) of
754 (physical) line TO_LINE in the current source file (as in the
755 most recent linemap_add). MAX_COLUMN_HINT is the highest column
756 number we expect to use in this line (but it does not change
757 the highest_location). */
759 location_t
760 linemap_line_start (line_maps *set, linenum_type to_line,
761 unsigned int max_column_hint)
763 line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
764 location_t highest = set->highest_location;
765 location_t r;
766 linenum_type last_line =
767 SOURCE_LINE (map, set->highest_line);
768 int line_delta = to_line - last_line;
769 bool add_map = false;
770 linemap_assert (map->m_column_and_range_bits >= map->m_range_bits);
771 int effective_column_bits = map->m_column_and_range_bits - map->m_range_bits;
773 if (line_delta < 0
774 || (line_delta > 10
775 && line_delta * map->m_column_and_range_bits > 1000)
776 || (max_column_hint >= (1U << effective_column_bits))
777 || (max_column_hint <= 80 && effective_column_bits >= 10)
778 || (highest > LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
779 && map->m_range_bits > 0)
780 || (highest > LINE_MAP_MAX_LOCATION_WITH_COLS
781 && (set->max_column_hint || highest >= LINE_MAP_MAX_LOCATION)))
782 add_map = true;
783 else
784 max_column_hint = set->max_column_hint;
785 if (add_map)
787 int column_bits;
788 int range_bits;
789 if (max_column_hint > LINE_MAP_MAX_COLUMN_NUMBER
790 || highest > LINE_MAP_MAX_LOCATION_WITH_COLS)
792 /* If the column number is ridiculous or we've allocated a huge
793 number of location_ts, give up on column numbers
794 (and on packed ranges). */
795 max_column_hint = 1;
796 column_bits = 0;
797 range_bits = 0;
798 if (highest >= LINE_MAP_MAX_LOCATION)
799 goto overflowed;
801 else
803 column_bits = 7;
804 if (highest <= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
805 range_bits = set->default_range_bits;
806 else
807 range_bits = 0;
808 while (max_column_hint >= (1U << column_bits))
809 column_bits++;
810 max_column_hint = 1U << column_bits;
811 column_bits += range_bits;
814 /* Allocate the new line_map. However, if the current map only has a
815 single line we can sometimes just increase its column_bits instead. */
816 if (line_delta < 0
817 || last_line != ORDINARY_MAP_STARTING_LINE_NUMBER (map)
818 || SOURCE_COLUMN (map, highest) >= (1U << (column_bits - range_bits))
819 || ( /* We can't reuse the map if the line offset is sufficiently
820 large to cause overflow when computing location_t values. */
821 (to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
822 >= (((uint64_t) 1)
823 << (CHAR_BIT * sizeof (linenum_type) - column_bits)))
824 || range_bits < map->m_range_bits)
825 map = linemap_check_ordinary
826 (const_cast <line_map *>
827 (linemap_add (set, LC_RENAME,
828 ORDINARY_MAP_IN_SYSTEM_HEADER_P (map),
829 ORDINARY_MAP_FILE_NAME (map),
830 to_line)));
831 map->m_column_and_range_bits = column_bits;
832 map->m_range_bits = range_bits;
833 r = (MAP_START_LOCATION (map)
834 + ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
835 << column_bits));
837 else
838 r = set->highest_line + (line_delta << map->m_column_and_range_bits);
840 /* Locations of ordinary tokens are always lower than locations of
841 macro tokens. */
842 if (r >= LINE_MAP_MAX_LOCATION)
844 overflowed:
845 /* Remember we overflowed. */
846 set->highest_line = set->highest_location = LINE_MAP_MAX_LOCATION - 1;
847 /* No column numbers! */
848 set->max_column_hint = 1;
849 return 0;
852 set->highest_line = r;
853 if (r > set->highest_location)
854 set->highest_location = r;
855 set->max_column_hint = max_column_hint;
857 /* At this point, we expect one of:
858 (a) the normal case: a "pure" location with 0 range bits, or
859 (b) we've gone past LINE_MAP_MAX_LOCATION_WITH_COLS so can't track
860 columns anymore (or ranges), or
861 (c) we're in a region with a column hint exceeding
862 LINE_MAP_MAX_COLUMN_NUMBER, so column-tracking is off,
863 with column_bits == 0. */
864 linemap_assert (pure_location_p (set, r)
865 || r >= LINE_MAP_MAX_LOCATION_WITH_COLS
866 || map->m_column_and_range_bits == 0);
867 linemap_assert (SOURCE_LINE (map, r) == to_line);
868 return r;
871 /* Encode and return a location_t from a column number. The
872 source line considered is the last source line used to call
873 linemap_line_start, i.e, the last source line which a location was
874 encoded from. */
876 location_t
877 linemap_position_for_column (line_maps *set, unsigned int to_column)
879 location_t r = set->highest_line;
881 linemap_assert
882 (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
884 if (to_column >= set->max_column_hint)
886 if (r > LINE_MAP_MAX_LOCATION_WITH_COLS
887 || to_column > LINE_MAP_MAX_COLUMN_NUMBER)
889 /* Running low on location_ts - disable column numbers. */
890 return r;
892 else
894 /* Otherwise, attempt to start a new line that can hold TO_COLUMN,
895 with some space to spare. This may or may not lead to a new
896 linemap being created. */
897 line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
898 r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
899 map = LINEMAPS_LAST_ORDINARY_MAP (set);
900 if (map->m_column_and_range_bits == 0)
902 /* ...then the linemap has column-tracking disabled,
903 presumably due to exceeding either
904 LINE_MAP_MAX_LOCATION_WITH_COLS (overall) or
905 LINE_MAP_MAX_COLUMN_NUMBER (within this line).
906 Return the start of the linemap, which encodes column 0, for
907 the whole line. */
908 return r;
912 line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
913 r = r + (to_column << map->m_range_bits);
914 if (r >= set->highest_location)
915 set->highest_location = r;
916 return r;
919 /* Encode and return a source location from a given line and
920 column. */
922 location_t
923 linemap_position_for_line_and_column (line_maps *set,
924 const line_map_ordinary *ord_map,
925 linenum_type line,
926 unsigned column)
928 linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map) <= line);
930 location_t r = MAP_START_LOCATION (ord_map);
931 r += ((line - ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map))
932 << ord_map->m_column_and_range_bits);
933 if (r <= LINE_MAP_MAX_LOCATION_WITH_COLS)
934 r += ((column & ((1 << ord_map->m_column_and_range_bits) - 1))
935 << ord_map->m_range_bits);
936 location_t upper_limit = LINEMAPS_MACRO_LOWEST_LOCATION (set);
937 if (r >= upper_limit)
938 r = upper_limit - 1;
939 if (r > set->highest_location)
940 set->highest_location = r;
941 return r;
944 /* Encode and return a location_t starting from location LOC and
945 shifting it by COLUMN_OFFSET columns. This function does not support
946 virtual locations. */
948 location_t
949 linemap_position_for_loc_and_offset (line_maps *set,
950 location_t loc,
951 unsigned int column_offset)
953 const line_map_ordinary * map = NULL;
955 if (IS_ADHOC_LOC (loc))
956 loc = get_location_from_adhoc_loc (set, loc);
958 /* This function does not support virtual locations yet. */
959 if (linemap_location_from_macro_expansion_p (set, loc))
960 return loc;
962 if (column_offset == 0
963 /* Adding an offset to a reserved location (like
964 UNKNOWN_LOCATION for the C/C++ FEs) does not really make
965 sense. So let's leave the location intact in that case. */
966 || loc < RESERVED_LOCATION_COUNT)
967 return loc;
969 /* We find the real location and shift it. */
970 loc = linemap_resolve_location (set, loc, LRK_SPELLING_LOCATION, &map);
971 /* The new location (loc + offset) should be higher than the first
972 location encoded by MAP. This can fail if the line information
973 is messed up because of line directives (see PR66415). */
974 if (MAP_START_LOCATION (map) >= loc + (column_offset << map->m_range_bits))
975 return loc;
977 linenum_type line = SOURCE_LINE (map, loc);
978 unsigned int column = SOURCE_COLUMN (map, loc);
980 /* If MAP is not the last line map of its set, then the new location
981 (loc + offset) should be less than the first location encoded by
982 the next line map of the set. Otherwise, we try to encode the
983 location in the next map. */
984 for (; map != LINEMAPS_LAST_ORDINARY_MAP (set)
985 && (loc + (column_offset << map->m_range_bits)
986 >= MAP_START_LOCATION (map + 1)); map++)
987 /* If the next map is a different file, or starts in a higher line, we
988 cannot encode the location there. */
989 if ((map + 1)->reason != LC_RENAME
990 || line < ORDINARY_MAP_STARTING_LINE_NUMBER (map + 1)
991 || 0 != strcmp (LINEMAP_FILE (map + 1), LINEMAP_FILE (map)))
992 return loc;
994 column += column_offset;
996 /* Bail out if the column is not representable within the existing
997 linemap. */
998 if (column >= (1u << (map->m_column_and_range_bits - map->m_range_bits)))
999 return loc;
1001 location_t r =
1002 linemap_position_for_line_and_column (set, map, line, column);
1003 if (linemap_assert_fails (r <= set->highest_location)
1004 || linemap_assert_fails (map == linemap_lookup (set, r)))
1005 return loc;
1007 return r;
1010 /* Given a virtual source location yielded by a map (either an
1011 ordinary or a macro map), returns that map. */
1013 const struct line_map*
1014 linemap_lookup (const line_maps *set, location_t line)
1016 if (IS_ADHOC_LOC (line))
1017 line = get_location_from_adhoc_loc (set, line);
1018 if (linemap_location_from_macro_expansion_p (set, line))
1019 return linemap_macro_map_lookup (set, line);
1020 return linemap_ordinary_map_lookup (set, line);
1023 /* Given a source location yielded by an ordinary map, returns that
1024 map. Since the set is built chronologically, the logical lines are
1025 monotonic increasing, and so the list is sorted and we can use a
1026 binary search. */
1028 static const line_map_ordinary *
1029 linemap_ordinary_map_lookup (const line_maps *set, location_t line)
1031 if (IS_ADHOC_LOC (line))
1032 line = get_location_from_adhoc_loc (set, line);
1034 if (set == NULL || line < RESERVED_LOCATION_COUNT)
1035 return NULL;
1037 unsigned mn = LINEMAPS_ORDINARY_CACHE (set);
1038 unsigned mx = LINEMAPS_ORDINARY_USED (set);
1040 const line_map_ordinary *cached = LINEMAPS_ORDINARY_MAP_AT (set, mn);
1041 /* We should get a segfault if no line_maps have been added yet. */
1042 if (line >= MAP_START_LOCATION (cached))
1044 if (mn + 1 == mx || line < MAP_START_LOCATION (&cached[1]))
1045 return cached;
1047 else
1049 mx = mn;
1050 mn = 0;
1053 while (mx - mn > 1)
1055 unsigned md = (mn + mx) / 2;
1056 if (MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (set, md)) > line)
1057 mx = md;
1058 else
1059 mn = md;
1062 LINEMAPS_ORDINARY_CACHE (set) = mn;
1063 const line_map_ordinary *result = LINEMAPS_ORDINARY_MAP_AT (set, mn);
1064 linemap_assert (line >= MAP_START_LOCATION (result));
1065 return result;
1068 /* Given a source location yielded by a macro map, returns that map.
1069 Since the set is built chronologically, the logical lines are
1070 monotonic decreasing, and so the list is sorted and we can use a
1071 binary search. */
1073 static const line_map_macro *
1074 linemap_macro_map_lookup (const line_maps *set, location_t line)
1076 if (IS_ADHOC_LOC (line))
1077 line = get_location_from_adhoc_loc (set, line);
1079 linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set));
1081 if (set == NULL)
1082 return NULL;
1084 unsigned ix = linemap_lookup_macro_index (set, line);
1085 const struct line_map_macro *result = LINEMAPS_MACRO_MAP_AT (set, ix);
1086 linemap_assert (MAP_START_LOCATION (result) <= line);
1088 return result;
1091 unsigned
1092 linemap_lookup_macro_index (const line_maps *set, location_t line)
1094 unsigned mn = LINEMAPS_MACRO_CACHE (set);
1095 unsigned mx = LINEMAPS_MACRO_USED (set);
1096 const struct line_map_macro *cached = LINEMAPS_MACRO_MAP_AT (set, mn);
1098 if (line >= MAP_START_LOCATION (cached))
1100 if (line < (MAP_START_LOCATION (cached)
1101 + MACRO_MAP_NUM_MACRO_TOKENS (cached)))
1102 return mn;
1103 mx = mn - 1;
1104 mn = 0;
1107 while (mn < mx)
1109 unsigned md = (mx + mn) / 2;
1110 if (MAP_START_LOCATION (LINEMAPS_MACRO_MAP_AT (set, md)) > line)
1111 mn = md + 1;
1112 else
1113 mx = md;
1116 LINEMAPS_MACRO_CACHE (set) = mx;
1117 return mx;
1120 /* Return TRUE if MAP encodes locations coming from a macro
1121 replacement-list at macro expansion point. */
1123 bool
1124 linemap_macro_expansion_map_p (const struct line_map *map)
1126 return map && !MAP_ORDINARY_P (map);
1129 /* If LOCATION is the locus of a token in a replacement-list of a
1130 macro expansion return the location of the macro expansion point.
1132 Read the comments of struct line_map and struct line_map_macro in
1133 line-map.h to understand what a macro expansion point is. */
1135 static location_t
1136 linemap_macro_map_loc_to_exp_point (const line_map_macro *map,
1137 location_t location ATTRIBUTE_UNUSED)
1139 linemap_assert (linemap_macro_expansion_map_p (map)
1140 && location >= MAP_START_LOCATION (map));
1142 /* Make sure LOCATION is correct. */
1143 linemap_assert ((location - MAP_START_LOCATION (map))
1144 < MACRO_MAP_NUM_MACRO_TOKENS (map));
1146 return MACRO_MAP_EXPANSION_POINT_LOCATION (map);
1149 /* LOCATION is the source location of a token that belongs to a macro
1150 replacement-list as part of the macro expansion denoted by MAP.
1152 Return the location of the token at the definition point of the
1153 macro. */
1155 static location_t
1156 linemap_macro_map_loc_to_def_point (const line_map_macro *map,
1157 location_t location)
1159 unsigned token_no;
1161 linemap_assert (linemap_macro_expansion_map_p (map)
1162 && location >= MAP_START_LOCATION (map));
1163 linemap_assert (location >= RESERVED_LOCATION_COUNT);
1165 token_no = location - MAP_START_LOCATION (map);
1166 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
1168 location = MACRO_MAP_LOCATIONS (map)[2 * token_no + 1];
1170 return location;
1173 /* If LOCATION is the locus of a token that is an argument of a
1174 function-like macro M and appears in the expansion of M, return the
1175 locus of that argument in the context of the caller of M.
1177 In other words, this returns the xI location presented in the
1178 comments of line_map_macro above. */
1179 location_t
1180 linemap_macro_map_loc_unwind_toward_spelling (line_maps *set,
1181 const line_map_macro* map,
1182 location_t location)
1184 unsigned token_no;
1186 if (IS_ADHOC_LOC (location))
1187 location = get_location_from_adhoc_loc (set, location);
1189 linemap_assert (linemap_macro_expansion_map_p (map)
1190 && location >= MAP_START_LOCATION (map));
1191 linemap_assert (location >= RESERVED_LOCATION_COUNT);
1192 linemap_assert (!IS_ADHOC_LOC (location));
1194 token_no = location - MAP_START_LOCATION (map);
1195 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
1197 location = MACRO_MAP_LOCATIONS (map)[2 * token_no];
1199 return location;
1202 /* Return the source line number corresponding to source location
1203 LOCATION. SET is the line map set LOCATION comes from. If
1204 LOCATION is the source location of token that is part of the
1205 replacement-list of a macro expansion return the line number of the
1206 macro expansion point. */
1209 linemap_get_expansion_line (line_maps *set,
1210 location_t location)
1212 const line_map_ordinary *map = NULL;
1214 if (IS_ADHOC_LOC (location))
1215 location = get_location_from_adhoc_loc (set, location);
1217 if (location < RESERVED_LOCATION_COUNT)
1218 return 0;
1220 location =
1221 linemap_macro_loc_to_exp_point (set, location, &map);
1223 return SOURCE_LINE (map, location);
1226 /* Return the path of the file corresponding to source code location
1227 LOCATION.
1229 If LOCATION is the source location of token that is part of the
1230 replacement-list of a macro expansion return the file path of the
1231 macro expansion point.
1233 SET is the line map set LOCATION comes from. */
1235 const char*
1236 linemap_get_expansion_filename (line_maps *set,
1237 location_t location)
1239 const struct line_map_ordinary *map = NULL;
1241 if (IS_ADHOC_LOC (location))
1242 location = get_location_from_adhoc_loc (set, location);
1244 if (location < RESERVED_LOCATION_COUNT)
1245 return NULL;
1247 linemap_macro_loc_to_exp_point (set, location, &map);
1249 return LINEMAP_FILE (map);
1252 /* Return the name of the macro associated to MACRO_MAP. */
1254 const char*
1255 linemap_map_get_macro_name (const line_map_macro *macro_map)
1257 linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map));
1258 return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map));
1261 /* Return a positive value if LOCATION is the locus of a token that is
1262 located in a system header, O otherwise. It returns 1 if LOCATION
1263 is the locus of a token that is located in a system header, and 2
1264 if LOCATION is the locus of a token located in a C system header
1265 that therefore needs to be extern "C" protected in C++.
1267 Note that this function returns 1 if LOCATION belongs to a token
1268 that is part of a macro replacement-list defined in a system
1269 header, but expanded in a non-system file. */
1272 linemap_location_in_system_header_p (line_maps *set,
1273 location_t location)
1275 const struct line_map *map = NULL;
1277 if (IS_ADHOC_LOC (location))
1278 location = get_location_from_adhoc_loc (set, location);
1280 if (location < RESERVED_LOCATION_COUNT)
1281 return false;
1283 /* Let's look at where the token for LOCATION comes from. */
1284 while (true)
1286 map = linemap_lookup (set, location);
1287 if (map != NULL)
1289 if (!linemap_macro_expansion_map_p (map))
1290 /* It's a normal token. */
1291 return LINEMAP_SYSP (linemap_check_ordinary (map));
1292 else
1294 const line_map_macro *macro_map = linemap_check_macro (map);
1296 /* It's a token resulting from a macro expansion. */
1297 location_t loc =
1298 linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, location);
1299 if (loc < RESERVED_LOCATION_COUNT)
1300 /* This token might come from a built-in macro. Let's
1301 look at where that macro got expanded. */
1302 location = linemap_macro_map_loc_to_exp_point (macro_map, location);
1303 else
1304 location = loc;
1307 else
1308 break;
1310 return false;
1313 /* Return TRUE if LOCATION is a source code location of a token that is part of
1314 a macro expansion, FALSE otherwise. */
1316 bool
1317 linemap_location_from_macro_expansion_p (const class line_maps *set,
1318 location_t location)
1320 if (IS_ADHOC_LOC (location))
1321 location = get_location_from_adhoc_loc (set, location);
1323 return location >= LINEMAPS_MACRO_LOWEST_LOCATION (set);
1326 /* Given two virtual locations *LOC0 and *LOC1, return the first
1327 common macro map in their macro expansion histories. Return NULL
1328 if no common macro was found. *LOC0 (resp. *LOC1) is set to the
1329 virtual location of the token inside the resulting macro. */
1331 static const struct line_map*
1332 first_map_in_common_1 (line_maps *set,
1333 location_t *loc0,
1334 location_t *loc1)
1336 location_t l0 = *loc0, l1 = *loc1;
1337 const struct line_map *map0 = linemap_lookup (set, l0);
1338 if (IS_ADHOC_LOC (l0))
1339 l0 = get_location_from_adhoc_loc (set, l0);
1341 const struct line_map *map1 = linemap_lookup (set, l1);
1342 if (IS_ADHOC_LOC (l1))
1343 l1 = get_location_from_adhoc_loc (set, l1);
1345 while (linemap_macro_expansion_map_p (map0)
1346 && linemap_macro_expansion_map_p (map1)
1347 && (map0 != map1))
1349 if (MAP_START_LOCATION (map0) < MAP_START_LOCATION (map1))
1351 l0 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map0),
1352 l0);
1353 map0 = linemap_lookup (set, l0);
1355 else
1357 l1 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map1),
1358 l1);
1359 map1 = linemap_lookup (set, l1);
1363 if (map0 == map1)
1365 *loc0 = l0;
1366 *loc1 = l1;
1367 return map0;
1369 return NULL;
1372 /* Given two virtual locations LOC0 and LOC1, return the first common
1373 macro map in their macro expansion histories. Return NULL if no
1374 common macro was found. *RES_LOC0 (resp. *RES_LOC1) is set to the
1375 virtual location of the token inside the resulting macro, upon
1376 return of a non-NULL result. */
1378 const struct line_map*
1379 first_map_in_common (line_maps *set,
1380 location_t loc0,
1381 location_t loc1,
1382 location_t *res_loc0,
1383 location_t *res_loc1)
1385 *res_loc0 = loc0;
1386 *res_loc1 = loc1;
1388 return first_map_in_common_1 (set, res_loc0, res_loc1);
1391 /* Return a positive value if PRE denotes the location of a token that
1392 comes before the token of POST, 0 if PRE denotes the location of
1393 the same token as the token for POST, and a negative value
1394 otherwise. */
1397 linemap_compare_locations (line_maps *set,
1398 location_t pre,
1399 location_t post)
1401 bool pre_virtual_p, post_virtual_p;
1402 location_t l0 = pre, l1 = post;
1404 if (IS_ADHOC_LOC (l0))
1405 l0 = get_location_from_adhoc_loc (set, l0);
1406 if (IS_ADHOC_LOC (l1))
1407 l1 = get_location_from_adhoc_loc (set, l1);
1409 if (l0 == l1)
1410 return 0;
1412 if ((pre_virtual_p = linemap_location_from_macro_expansion_p (set, l0)))
1413 l0 = linemap_resolve_location (set, l0,
1414 LRK_MACRO_EXPANSION_POINT,
1415 NULL);
1417 if ((post_virtual_p = linemap_location_from_macro_expansion_p (set, l1)))
1418 l1 = linemap_resolve_location (set, l1,
1419 LRK_MACRO_EXPANSION_POINT,
1420 NULL);
1422 if (l0 == l1
1423 && pre_virtual_p
1424 && post_virtual_p)
1426 /* So pre and post represent two tokens that are present in a
1427 same macro expansion. Let's see if the token for pre was
1428 before the token for post in that expansion. */
1429 const struct line_map *map =
1430 first_map_in_common (set, pre, post, &l0, &l1);
1432 if (map == NULL)
1433 /* This should not be possible while we have column information, but if
1434 we don't, the tokens could be from separate macro expansions on the
1435 same line. */
1436 gcc_assert (l0 > LINE_MAP_MAX_LOCATION_WITH_COLS);
1437 else
1439 unsigned i0 = l0 - MAP_START_LOCATION (map);
1440 unsigned i1 = l1 - MAP_START_LOCATION (map);
1441 return i1 - i0;
1445 if (IS_ADHOC_LOC (l0))
1446 l0 = get_location_from_adhoc_loc (set, l0);
1447 if (IS_ADHOC_LOC (l1))
1448 l1 = get_location_from_adhoc_loc (set, l1);
1450 return l1 - l0;
1453 /* Print an include trace, for e.g. the -H option of the preprocessor. */
1455 static void
1456 trace_include (const class line_maps *set, const line_map_ordinary *map)
1458 unsigned int i = set->depth;
1460 while (--i)
1461 putc ('.', stderr);
1463 fprintf (stderr, " %s\n", ORDINARY_MAP_FILE_NAME (map));
1466 /* Return the spelling location of the token wherever it comes from,
1467 whether part of a macro definition or not.
1469 This is a subroutine for linemap_resolve_location. */
1471 static location_t
1472 linemap_macro_loc_to_spelling_point (line_maps *set,
1473 location_t location,
1474 const line_map_ordinary **original_map)
1476 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1478 while (true)
1480 const struct line_map *map = linemap_lookup (set, location);
1481 if (!map || MAP_ORDINARY_P (map))
1483 if (original_map)
1484 *original_map = (const line_map_ordinary *)map;
1485 break;
1488 location = linemap_macro_map_loc_unwind_toward_spelling
1489 (set, linemap_check_macro (map), location);
1492 return location;
1495 /* If LOCATION is the source location of a token that belongs to a
1496 macro replacement-list -- as part of a macro expansion -- then
1497 return the location of the token at the definition point of the
1498 macro. Otherwise, return LOCATION. SET is the set of maps
1499 location come from. ORIGINAL_MAP is an output parm. If non NULL,
1500 the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
1501 returned location comes from.
1503 This is a subroutine of linemap_resolve_location. */
1505 static location_t
1506 linemap_macro_loc_to_def_point (line_maps *set,
1507 location_t location,
1508 const line_map_ordinary **original_map)
1510 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1512 for (;;)
1514 location_t caret_loc = location;
1515 if (IS_ADHOC_LOC (caret_loc))
1516 caret_loc = get_location_from_adhoc_loc (set, caret_loc);
1518 const line_map *map = linemap_lookup (set, caret_loc);
1519 if (!map || MAP_ORDINARY_P (map))
1521 if (original_map)
1522 *original_map = (const line_map_ordinary *)map;
1523 break;
1526 location = linemap_macro_map_loc_to_def_point
1527 (linemap_check_macro (map), caret_loc);
1530 return location;
1533 /* If LOCATION is the source location of a token that belongs to a
1534 macro replacement-list -- at a macro expansion point -- then return
1535 the location of the topmost expansion point of the macro. We say
1536 topmost because if we are in the context of a nested macro
1537 expansion, the function returns the source location of the first
1538 macro expansion that triggered the nested expansions.
1540 Otherwise, return LOCATION. SET is the set of maps location come
1541 from. ORIGINAL_MAP is an output parm. If non NULL, the function
1542 sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
1543 location comes from.
1545 This is a subroutine of linemap_resolve_location. */
1547 static location_t
1548 linemap_macro_loc_to_exp_point (line_maps *set,
1549 location_t location,
1550 const line_map_ordinary **original_map)
1552 struct line_map *map;
1554 if (IS_ADHOC_LOC (location))
1555 location = get_location_from_adhoc_loc (set, location);
1557 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1559 while (true)
1561 map = const_cast <line_map *> (linemap_lookup (set, location));
1562 if (!linemap_macro_expansion_map_p (map))
1563 break;
1564 location = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map),
1565 location);
1568 if (original_map)
1569 *original_map = linemap_check_ordinary (map);
1570 return location;
1573 /* Resolve a virtual location into either a spelling location, an
1574 expansion point location or a token argument replacement point
1575 location. Return the map that encodes the virtual location as well
1576 as the resolved location.
1578 If LOC is *NOT* the location of a token resulting from the
1579 expansion of a macro, then the parameter LRK (which stands for
1580 Location Resolution Kind) is ignored and the resulting location
1581 just equals the one given in argument.
1583 Now if LOC *IS* the location of a token resulting from the
1584 expansion of a macro, this is what happens.
1586 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1587 -------------------------------
1589 The virtual location is resolved to the first macro expansion point
1590 that led to this macro expansion.
1592 * If LRK is set to LRK_SPELLING_LOCATION
1593 -------------------------------------
1595 The virtual location is resolved to the locus where the token has
1596 been spelled in the source. This can follow through all the macro
1597 expansions that led to the token.
1599 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1600 --------------------------------------
1602 The virtual location is resolved to the locus of the token in the
1603 context of the macro definition.
1605 If LOC is the locus of a token that is an argument of a
1606 function-like macro [replacing a parameter in the replacement list
1607 of the macro] the virtual location is resolved to the locus of the
1608 parameter that is replaced, in the context of the definition of the
1609 macro.
1611 If LOC is the locus of a token that is not an argument of a
1612 function-like macro, then the function behaves as if LRK was set to
1613 LRK_SPELLING_LOCATION.
1615 If MAP is not NULL, *MAP is set to the map encoding the
1616 returned location. Note that if the returned location wasn't originally
1617 encoded by a map, then *MAP is set to NULL. This can happen if LOC
1618 resolves to a location reserved for the client code, like
1619 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1621 location_t
1622 linemap_resolve_location (line_maps *set,
1623 location_t loc,
1624 enum location_resolution_kind lrk,
1625 const line_map_ordinary **map)
1627 location_t locus = loc;
1628 if (IS_ADHOC_LOC (loc))
1629 locus = get_location_from_adhoc_loc (set, loc);
1631 if (locus < RESERVED_LOCATION_COUNT)
1633 /* A reserved location wasn't encoded in a map. Let's return a
1634 NULL map here, just like what linemap_ordinary_map_lookup
1635 does. */
1636 if (map)
1637 *map = NULL;
1638 return loc;
1641 switch (lrk)
1643 case LRK_MACRO_EXPANSION_POINT:
1644 loc = linemap_macro_loc_to_exp_point (set, loc, map);
1645 break;
1646 case LRK_SPELLING_LOCATION:
1647 loc = linemap_macro_loc_to_spelling_point (set, loc, map);
1648 break;
1649 case LRK_MACRO_DEFINITION_LOCATION:
1650 loc = linemap_macro_loc_to_def_point (set, loc, map);
1651 break;
1652 default:
1653 abort ();
1655 return loc;
1658 /* TRUE if LOCATION is a source code location of a token that is part of the
1659 definition of a macro, FALSE otherwise. */
1661 bool
1662 linemap_location_from_macro_definition_p (line_maps *set,
1663 location_t loc)
1665 if (IS_ADHOC_LOC (loc))
1666 loc = get_location_from_adhoc_loc (set, loc);
1668 if (!linemap_location_from_macro_expansion_p (set, loc))
1669 return false;
1671 while (true)
1673 const struct line_map_macro *map
1674 = linemap_check_macro (linemap_lookup (set, loc));
1676 location_t s_loc
1677 = linemap_macro_map_loc_unwind_toward_spelling (set, map, loc);
1678 if (linemap_location_from_macro_expansion_p (set, s_loc))
1679 loc = s_loc;
1680 else
1682 location_t def_loc
1683 = linemap_macro_map_loc_to_def_point (map, loc);
1684 return s_loc == def_loc;
1690 Suppose that LOC is the virtual location of a token T coming from
1691 the expansion of a macro M. This function then steps up to get the
1692 location L of the point where M got expanded. If L is a spelling
1693 location inside a macro expansion M', then this function returns
1694 the locus of the point where M' was expanded. Said otherwise, this
1695 function returns the location of T in the context that triggered
1696 the expansion of M.
1698 *LOC_MAP must be set to the map of LOC. This function then sets it
1699 to the map of the returned location. */
1701 location_t
1702 linemap_unwind_toward_expansion (line_maps *set,
1703 location_t loc,
1704 const struct line_map **map)
1706 location_t resolved_location;
1707 const line_map_macro *macro_map = linemap_check_macro (*map);
1708 const struct line_map *resolved_map;
1710 if (IS_ADHOC_LOC (loc))
1711 loc = get_location_from_adhoc_loc (set, loc);
1713 resolved_location =
1714 linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, loc);
1715 resolved_map = linemap_lookup (set, resolved_location);
1717 if (!linemap_macro_expansion_map_p (resolved_map))
1719 resolved_location = linemap_macro_map_loc_to_exp_point (macro_map, loc);
1720 resolved_map = linemap_lookup (set, resolved_location);
1723 *map = resolved_map;
1724 return resolved_location;
1727 /* If LOC is the virtual location of a token coming from the expansion
1728 of a macro M and if its spelling location is reserved (e.g, a
1729 location for a built-in token), then this function unwinds (using
1730 linemap_unwind_toward_expansion) the location until a location that
1731 is not reserved and is not in a system header is reached. In other
1732 words, this unwinds the reserved location until a location that is
1733 in real source code is reached.
1735 Otherwise, if the spelling location for LOC is not reserved or if
1736 LOC doesn't come from the expansion of a macro, the function
1737 returns LOC as is and *MAP is not touched.
1739 *MAP is set to the map of the returned location if the later is
1740 different from LOC. */
1741 location_t
1742 linemap_unwind_to_first_non_reserved_loc (line_maps *set,
1743 location_t loc,
1744 const struct line_map **map)
1746 location_t resolved_loc;
1747 const struct line_map *map0 = NULL;
1748 const line_map_ordinary *map1 = NULL;
1750 if (IS_ADHOC_LOC (loc))
1751 loc = get_location_from_adhoc_loc (set, loc);
1753 map0 = linemap_lookup (set, loc);
1754 if (!linemap_macro_expansion_map_p (map0))
1755 return loc;
1757 resolved_loc = linemap_resolve_location (set, loc,
1758 LRK_SPELLING_LOCATION,
1759 &map1);
1761 if (resolved_loc >= RESERVED_LOCATION_COUNT
1762 && !LINEMAP_SYSP (map1))
1763 return loc;
1765 while (linemap_macro_expansion_map_p (map0)
1766 && (resolved_loc < RESERVED_LOCATION_COUNT
1767 || LINEMAP_SYSP (map1)))
1769 loc = linemap_unwind_toward_expansion (set, loc, &map0);
1770 resolved_loc = linemap_resolve_location (set, loc,
1771 LRK_SPELLING_LOCATION,
1772 &map1);
1775 if (map != NULL)
1776 *map = map0;
1777 return loc;
1780 /* Expand source code location LOC and return a user readable source
1781 code location. LOC must be a spelling (non-virtual) location. If
1782 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1783 location is returned. */
1785 expanded_location
1786 linemap_expand_location (line_maps *set,
1787 const struct line_map *map,
1788 location_t loc)
1791 expanded_location xloc;
1793 memset (&xloc, 0, sizeof (xloc));
1794 if (IS_ADHOC_LOC (loc))
1796 xloc.data = get_data_from_adhoc_loc (set, loc);
1797 loc = get_location_from_adhoc_loc (set, loc);
1800 if (loc < RESERVED_LOCATION_COUNT)
1801 /* The location for this token wasn't generated from a line map.
1802 It was probably a location for a builtin token, chosen by some
1803 client code. Let's not try to expand the location in that
1804 case. */;
1805 else if (map == NULL)
1806 /* We shouldn't be getting a NULL map with a location that is not
1807 reserved by the client code. */
1808 abort ();
1809 else
1811 /* MAP must be an ordinary map and LOC must be non-virtual,
1812 encoded into this map, obviously; the accessors used on MAP
1813 below ensure it is ordinary. Let's just assert the
1814 non-virtualness of LOC here. */
1815 if (linemap_location_from_macro_expansion_p (set, loc))
1816 abort ();
1818 const line_map_ordinary *ord_map = linemap_check_ordinary (map);
1820 xloc.file = LINEMAP_FILE (ord_map);
1821 xloc.line = SOURCE_LINE (ord_map, loc);
1822 xloc.column = SOURCE_COLUMN (ord_map, loc);
1823 xloc.sysp = LINEMAP_SYSP (ord_map) != 0;
1826 return xloc;
1830 /* Dump line map at index IX in line table SET to STREAM. If STREAM
1831 is NULL, use stderr. IS_MACRO is true if the caller wants to
1832 dump a macro map, false otherwise. */
1834 void
1835 linemap_dump (FILE *stream, class line_maps *set, unsigned ix, bool is_macro)
1837 const char *const lc_reasons_v[LC_HWM]
1838 = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
1839 "LC_ENTER_MACRO", "LC_MODULE" };
1840 const line_map *map;
1841 unsigned reason;
1843 if (stream == NULL)
1844 stream = stderr;
1846 if (!is_macro)
1848 map = LINEMAPS_ORDINARY_MAP_AT (set, ix);
1849 reason = linemap_check_ordinary (map)->reason;
1851 else
1853 map = LINEMAPS_MACRO_MAP_AT (set, ix);
1854 reason = LC_ENTER_MACRO;
1857 fprintf (stream, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
1858 ix, (void *) map, map->start_location,
1859 reason < LC_HWM ? lc_reasons_v[reason] : "???",
1860 ((!is_macro
1861 && ORDINARY_MAP_IN_SYSTEM_HEADER_P (linemap_check_ordinary (map)))
1862 ? "yes" : "no"));
1863 if (!is_macro)
1865 const line_map_ordinary *ord_map = linemap_check_ordinary (map);
1866 const line_map_ordinary *includer_map
1867 = linemap_included_from_linemap (set, ord_map);
1869 fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map),
1870 ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map));
1871 fprintf (stream, "Included from: [%d] %s\n",
1872 includer_map ? int (includer_map - set->info_ordinary.maps) : -1,
1873 includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None");
1875 else
1877 const line_map_macro *macro_map = linemap_check_macro (map);
1878 fprintf (stream, "Macro: %s (%u tokens)\n",
1879 linemap_map_get_macro_name (macro_map),
1880 MACRO_MAP_NUM_MACRO_TOKENS (macro_map));
1883 fprintf (stream, "\n");
1887 /* Dump debugging information about source location LOC into the file
1888 stream STREAM. SET is the line map set LOC comes from. */
1890 void
1891 linemap_dump_location (line_maps *set,
1892 location_t loc,
1893 FILE *stream)
1895 const line_map_ordinary *map;
1896 location_t location;
1897 const char *path = "", *from = "";
1898 int l = -1, c = -1, s = -1, e = -1;
1900 if (IS_ADHOC_LOC (loc))
1901 loc = get_location_from_adhoc_loc (set, loc);
1903 if (loc == 0)
1904 return;
1906 location =
1907 linemap_resolve_location (set, loc, LRK_MACRO_DEFINITION_LOCATION, &map);
1909 if (map == NULL)
1910 /* Only reserved locations can be tolerated in this case. */
1911 linemap_assert (location < RESERVED_LOCATION_COUNT);
1912 else
1914 path = LINEMAP_FILE (map);
1915 l = SOURCE_LINE (map, location);
1916 c = SOURCE_COLUMN (map, location);
1917 s = LINEMAP_SYSP (map) != 0;
1918 e = location != loc;
1919 if (e)
1920 from = "N/A";
1921 else
1923 const line_map_ordinary *from_map
1924 = linemap_included_from_linemap (set, map);
1925 from = from_map ? LINEMAP_FILE (from_map) : "<NULL>";
1929 /* P: path, L: line, C: column, S: in-system-header, M: map address,
1930 E: macro expansion?, LOC: original location, R: resolved location */
1931 fprintf (stream, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}",
1932 path, from, l, c, s, (void*)map, e, loc, location);
1935 /* Return the highest location emitted for a given file for which
1936 there is a line map in SET. FILE_NAME is the file name to
1937 consider. If the function returns TRUE, *LOC is set to the highest
1938 location emitted for that file. */
1940 bool
1941 linemap_get_file_highest_location (line_maps *set,
1942 const char *file_name,
1943 location_t *loc)
1945 /* If the set is empty or no ordinary map has been created then
1946 there is no file to look for ... */
1947 if (set == NULL || set->info_ordinary.used == 0)
1948 return false;
1950 /* Now look for the last ordinary map created for FILE_NAME. */
1951 int i;
1952 for (i = set->info_ordinary.used - 1; i >= 0; --i)
1954 const char *fname = set->info_ordinary.maps[i].to_file;
1955 if (fname && !filename_cmp (fname, file_name))
1956 break;
1959 if (i < 0)
1960 return false;
1962 /* The highest location for a given map is either the starting
1963 location of the next map minus one, or -- if the map is the
1964 latest one -- the highest location of the set. */
1965 location_t result;
1966 if (i == (int) set->info_ordinary.used - 1)
1967 result = set->highest_location;
1968 else
1969 result = set->info_ordinary.maps[i + 1].start_location - 1;
1971 *loc = result;
1972 return true;
1975 /* Compute and return statistics about the memory consumption of some
1976 parts of the line table SET. */
1978 void
1979 linemap_get_statistics (line_maps *set,
1980 struct linemap_stats *s)
1982 long ordinary_maps_allocated_size, ordinary_maps_used_size,
1983 macro_maps_allocated_size, macro_maps_used_size,
1984 macro_maps_locations_size = 0, duplicated_macro_maps_locations_size = 0;
1986 const line_map_macro *cur_map;
1988 ordinary_maps_allocated_size =
1989 LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map_ordinary);
1991 ordinary_maps_used_size =
1992 LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map_ordinary);
1994 macro_maps_allocated_size =
1995 LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map_macro);
1997 for (cur_map = LINEMAPS_MACRO_MAPS (set);
1998 cur_map && cur_map <= LINEMAPS_LAST_MACRO_MAP (set);
1999 ++cur_map)
2001 unsigned i;
2003 linemap_assert (linemap_macro_expansion_map_p (cur_map));
2005 macro_maps_locations_size +=
2006 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map) * sizeof (location_t);
2008 for (i = 0; i < 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map); i += 2)
2010 if (MACRO_MAP_LOCATIONS (cur_map)[i] ==
2011 MACRO_MAP_LOCATIONS (cur_map)[i + 1])
2012 duplicated_macro_maps_locations_size +=
2013 sizeof (location_t);
2017 macro_maps_used_size =
2018 LINEMAPS_MACRO_USED (set) * sizeof (struct line_map_macro);
2020 s->num_ordinary_maps_allocated = LINEMAPS_ORDINARY_ALLOCATED (set);
2021 s->num_ordinary_maps_used = LINEMAPS_ORDINARY_USED (set);
2022 s->ordinary_maps_allocated_size = ordinary_maps_allocated_size;
2023 s->ordinary_maps_used_size = ordinary_maps_used_size;
2024 s->num_expanded_macros = num_expanded_macros_counter;
2025 s->num_macro_tokens = num_macro_tokens_counter;
2026 s->num_macro_maps_used = LINEMAPS_MACRO_USED (set);
2027 s->macro_maps_allocated_size = macro_maps_allocated_size;
2028 s->macro_maps_locations_size = macro_maps_locations_size;
2029 s->macro_maps_used_size = macro_maps_used_size;
2030 s->duplicated_macro_maps_locations_size =
2031 duplicated_macro_maps_locations_size;
2032 s->adhoc_table_size = (set->location_adhoc_data_map.allocated
2033 * sizeof (struct location_adhoc_data));
2034 s->adhoc_table_entries_used = set->location_adhoc_data_map.curr_loc;
2038 /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
2039 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
2040 specifies how many macro maps to dump. */
2042 void
2043 line_table_dump (FILE *stream, class line_maps *set, unsigned int num_ordinary,
2044 unsigned int num_macro)
2046 unsigned int i;
2048 if (set == NULL)
2049 return;
2051 if (stream == NULL)
2052 stream = stderr;
2054 fprintf (stream, "# of ordinary maps: %d\n", LINEMAPS_ORDINARY_USED (set));
2055 fprintf (stream, "# of macro maps: %d\n", LINEMAPS_MACRO_USED (set));
2056 fprintf (stream, "Include stack depth: %d\n", set->depth);
2057 fprintf (stream, "Highest location: %u\n", set->highest_location);
2059 if (num_ordinary)
2061 fprintf (stream, "\nOrdinary line maps\n");
2062 for (i = 0; i < num_ordinary && i < LINEMAPS_ORDINARY_USED (set); i++)
2063 linemap_dump (stream, set, i, false);
2064 fprintf (stream, "\n");
2067 if (num_macro)
2069 fprintf (stream, "\nMacro line maps\n");
2070 for (i = 0; i < num_macro && i < LINEMAPS_MACRO_USED (set); i++)
2071 linemap_dump (stream, set, i, true);
2072 fprintf (stream, "\n");
2076 /* class rich_location. */
2078 /* Construct a rich_location with location LOC as its initial range. */
2080 rich_location::rich_location (line_maps *set, location_t loc,
2081 const range_label *label) :
2082 m_line_table (set),
2083 m_ranges (),
2084 m_column_override (0),
2085 m_have_expanded_location (false),
2086 m_fixit_hints (),
2087 m_seen_impossible_fixit (false),
2088 m_fixits_cannot_be_auto_applied (false),
2089 m_path (NULL),
2090 m_escape_on_output (false)
2092 add_range (loc, SHOW_RANGE_WITH_CARET, label);
2095 /* The destructor for class rich_location. */
2097 rich_location::~rich_location ()
2099 for (unsigned int i = 0; i < m_fixit_hints.count (); i++)
2100 delete get_fixit_hint (i);
2103 /* Get location IDX within this rich_location. */
2105 location_t
2106 rich_location::get_loc (unsigned int idx) const
2108 const location_range *locrange = get_range (idx);
2109 return locrange->m_loc;
2112 /* Get range IDX within this rich_location. */
2114 const location_range *
2115 rich_location::get_range (unsigned int idx) const
2117 return &m_ranges[idx];
2120 /* Mutable access to range IDX within this rich_location. */
2122 location_range *
2123 rich_location::get_range (unsigned int idx)
2125 return &m_ranges[idx];
2128 /* Expand location IDX within this rich_location. */
2129 /* Get an expanded_location for this rich_location's primary
2130 location. */
2132 expanded_location
2133 rich_location::get_expanded_location (unsigned int idx)
2135 if (idx == 0)
2137 /* Cache the expansion of the primary location. */
2138 if (!m_have_expanded_location)
2140 m_expanded_location
2141 = linemap_client_expand_location_to_spelling_point
2142 (get_loc (0), LOCATION_ASPECT_CARET);
2143 if (m_column_override)
2144 m_expanded_location.column = m_column_override;
2145 m_have_expanded_location = true;
2148 return m_expanded_location;
2150 else
2151 return linemap_client_expand_location_to_spelling_point
2152 (get_loc (idx), LOCATION_ASPECT_CARET);
2155 /* Set the column of the primary location, with 0 meaning
2156 "don't override it". */
2158 void
2159 rich_location::override_column (int column)
2161 m_column_override = column;
2162 m_have_expanded_location = false;
2165 /* Add the given range. */
2167 void
2168 rich_location::add_range (location_t loc,
2169 enum range_display_kind range_display_kind,
2170 const range_label *label)
2172 location_range range;
2173 range.m_loc = loc;
2174 range.m_range_display_kind = range_display_kind;
2175 range.m_label = label;
2176 m_ranges.push (range);
2179 /* Add or overwrite the location given by IDX, setting its location to LOC,
2180 and setting its m_range_display_kind to RANGE_DISPLAY_KIND.
2182 It must either overwrite an existing location, or add one *exactly* on
2183 the end of the array.
2185 This is primarily for use by gcc when implementing diagnostic format
2186 decoders e.g.
2187 - the "+" in the C/C++ frontends, for handling format codes like "%q+D"
2188 (which writes the source location of a tree back into location 0 of
2189 the rich_location), and
2190 - the "%C" and "%L" format codes in the Fortran frontend. */
2192 void
2193 rich_location::set_range (unsigned int idx, location_t loc,
2194 enum range_display_kind range_display_kind)
2196 /* We can either overwrite an existing range, or add one exactly
2197 on the end of the array. */
2198 linemap_assert (idx <= m_ranges.count ());
2200 if (idx == m_ranges.count ())
2201 add_range (loc, range_display_kind);
2202 else
2204 location_range *locrange = get_range (idx);
2205 locrange->m_loc = loc;
2206 locrange->m_range_display_kind = range_display_kind;
2209 if (idx == 0)
2210 /* Mark any cached value here as dirty. */
2211 m_have_expanded_location = false;
2214 /* Methods for adding insertion fix-it hints. */
2216 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2217 immediately before the primary range's start location. */
2219 void
2220 rich_location::add_fixit_insert_before (const char *new_content)
2222 add_fixit_insert_before (get_loc (), new_content);
2225 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2226 immediately before the start of WHERE. */
2228 void
2229 rich_location::add_fixit_insert_before (location_t where,
2230 const char *new_content)
2232 location_t start = get_range_from_loc (m_line_table, where).m_start;
2233 maybe_add_fixit (start, start, new_content);
2236 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2237 immediately after the primary range's end-point. */
2239 void
2240 rich_location::add_fixit_insert_after (const char *new_content)
2242 add_fixit_insert_after (get_loc (), new_content);
2245 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2246 immediately after the end-point of WHERE. */
2248 void
2249 rich_location::add_fixit_insert_after (location_t where,
2250 const char *new_content)
2252 location_t finish = get_range_from_loc (m_line_table, where).m_finish;
2253 location_t next_loc
2254 = linemap_position_for_loc_and_offset (m_line_table, finish, 1);
2256 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2257 its input value. */
2258 if (next_loc == finish)
2260 stop_supporting_fixits ();
2261 return;
2264 maybe_add_fixit (next_loc, next_loc, new_content);
2267 /* Methods for adding removal fix-it hints. */
2269 /* Add a fixit-hint, suggesting removal of the content covered
2270 by range 0. */
2272 void
2273 rich_location::add_fixit_remove ()
2275 add_fixit_remove (get_loc ());
2278 /* Add a fixit-hint, suggesting removal of the content between
2279 the start and finish of WHERE. */
2281 void
2282 rich_location::add_fixit_remove (location_t where)
2284 source_range range = get_range_from_loc (m_line_table, where);
2285 add_fixit_remove (range);
2288 /* Add a fixit-hint, suggesting removal of the content at
2289 SRC_RANGE. */
2291 void
2292 rich_location::add_fixit_remove (source_range src_range)
2294 add_fixit_replace (src_range, "");
2297 /* Add a fixit-hint, suggesting replacement of the content covered
2298 by range 0 with NEW_CONTENT. */
2300 void
2301 rich_location::add_fixit_replace (const char *new_content)
2303 add_fixit_replace (get_loc (), new_content);
2306 /* Methods for adding "replace" fix-it hints. */
2308 /* Add a fixit-hint, suggesting replacement of the content between
2309 the start and finish of WHERE with NEW_CONTENT. */
2311 void
2312 rich_location::add_fixit_replace (location_t where,
2313 const char *new_content)
2315 source_range range = get_range_from_loc (m_line_table, where);
2316 add_fixit_replace (range, new_content);
2319 /* Add a fixit-hint, suggesting replacement of the content at
2320 SRC_RANGE with NEW_CONTENT. */
2322 void
2323 rich_location::add_fixit_replace (source_range src_range,
2324 const char *new_content)
2326 location_t start = get_pure_location (m_line_table, src_range.m_start);
2327 location_t finish = get_pure_location (m_line_table, src_range.m_finish);
2329 /* Fix-it hints use half-closed ranges, so attempt to offset the endpoint. */
2330 location_t next_loc
2331 = linemap_position_for_loc_and_offset (m_line_table, finish, 1);
2332 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2333 its input value. */
2334 if (next_loc == finish)
2336 stop_supporting_fixits ();
2337 return;
2339 finish = next_loc;
2341 maybe_add_fixit (start, finish, new_content);
2344 /* Get the last fix-it hint within this rich_location, or NULL if none. */
2346 fixit_hint *
2347 rich_location::get_last_fixit_hint () const
2349 if (m_fixit_hints.count () > 0)
2350 return get_fixit_hint (m_fixit_hints.count () - 1);
2351 else
2352 return NULL;
2355 /* If WHERE is an "awkward" location, then mark this rich_location as not
2356 supporting fixits, purging any thay were already added, and return true.
2358 Otherwise (the common case), return false. */
2360 bool
2361 rich_location::reject_impossible_fixit (location_t where)
2363 /* Fix-its within a rich_location should either all be suggested, or
2364 none of them should be suggested.
2365 Once we've rejected a fixit, we reject any more, even those
2366 with reasonable locations. */
2367 if (m_seen_impossible_fixit)
2368 return true;
2370 if (where <= LINE_MAP_MAX_LOCATION_WITH_COLS)
2371 /* WHERE is a reasonable location for a fix-it; don't reject it. */
2372 return false;
2374 /* Otherwise we have an attempt to add a fix-it with an "awkward"
2375 location: either one that we can't obtain column information
2376 for (within an ordinary map), or one within a macro expansion. */
2377 stop_supporting_fixits ();
2378 return true;
2381 /* Mark this rich_location as not supporting fixits, purging any that were
2382 already added. */
2384 void
2385 rich_location::stop_supporting_fixits ()
2387 m_seen_impossible_fixit = true;
2389 /* Purge the rich_location of any fix-its that were already added. */
2390 for (unsigned int i = 0; i < m_fixit_hints.count (); i++)
2391 delete get_fixit_hint (i);
2392 m_fixit_hints.truncate (0);
2395 /* Add HINT to the fix-it hints in this rich_location,
2396 consolidating into the prior fixit if possible. */
2398 void
2399 rich_location::maybe_add_fixit (location_t start,
2400 location_t next_loc,
2401 const char *new_content)
2403 if (reject_impossible_fixit (start))
2404 return;
2405 if (reject_impossible_fixit (next_loc))
2406 return;
2408 /* Only allow fix-it hints that affect a single line in one file.
2409 Compare the end-points. */
2410 expanded_location exploc_start
2411 = linemap_client_expand_location_to_spelling_point (start,
2412 LOCATION_ASPECT_START);
2413 expanded_location exploc_next_loc
2414 = linemap_client_expand_location_to_spelling_point (next_loc,
2415 LOCATION_ASPECT_START);
2416 /* They must be within the same file... */
2417 if (exploc_start.file != exploc_next_loc.file)
2419 stop_supporting_fixits ();
2420 return;
2422 /* ...and on the same line. */
2423 if (exploc_start.line != exploc_next_loc.line)
2425 stop_supporting_fixits ();
2426 return;
2428 /* The columns must be in the correct order. This can fail if the
2429 endpoints straddle the boundary for which the linemap can represent
2430 columns (PR c/82050). */
2431 if (exploc_start.column > exploc_next_loc.column)
2433 stop_supporting_fixits ();
2434 return;
2436 /* If we have very long lines, tokens will eventually fall back to
2437 having column == 0.
2438 We can't handle fix-it hints that use such locations. */
2439 if (exploc_start.column == 0 || exploc_next_loc.column == 0)
2441 stop_supporting_fixits ();
2442 return;
2445 const char *newline = strchr (new_content, '\n');
2446 if (newline)
2448 /* For now, we can only support insertion of whole lines
2449 i.e. starts at start of line, and the newline is at the end of
2450 the insertion point. */
2452 /* It must be an insertion, not a replacement/deletion. */
2453 if (start != next_loc)
2455 stop_supporting_fixits ();
2456 return;
2459 /* The insertion must be at the start of a line. */
2460 if (exploc_start.column != 1)
2462 stop_supporting_fixits ();
2463 return;
2466 /* The newline must be at end of NEW_CONTENT.
2467 We could eventually split up fix-its at newlines if we wanted
2468 to allow more generality (e.g. to allow adding multiple lines
2469 with one add_fixit call. */
2470 if (newline[1] != '\0')
2472 stop_supporting_fixits ();
2473 return;
2477 /* Consolidate neighboring fixits.
2478 Don't consolidate into newline-insertion fixits. */
2479 fixit_hint *prev = get_last_fixit_hint ();
2480 if (prev && !prev->ends_with_newline_p ())
2481 if (prev->maybe_append (start, next_loc, new_content))
2482 return;
2484 m_fixit_hints.push (new fixit_hint (start, next_loc, new_content));
2487 /* class fixit_hint. */
2489 fixit_hint::fixit_hint (location_t start,
2490 location_t next_loc,
2491 const char *new_content)
2492 : m_start (start),
2493 m_next_loc (next_loc),
2494 m_bytes (xstrdup (new_content)),
2495 m_len (strlen (new_content))
2499 /* Does this fix-it hint affect the given line? */
2501 bool
2502 fixit_hint::affects_line_p (const char *file, int line) const
2504 expanded_location exploc_start
2505 = linemap_client_expand_location_to_spelling_point (m_start,
2506 LOCATION_ASPECT_START);
2507 if (file != exploc_start.file)
2508 return false;
2509 if (line < exploc_start.line)
2510 return false;
2511 expanded_location exploc_next_loc
2512 = linemap_client_expand_location_to_spelling_point (m_next_loc,
2513 LOCATION_ASPECT_START);
2514 if (file != exploc_next_loc.file)
2515 return false;
2516 if (line > exploc_next_loc.line)
2517 return false;
2518 return true;
2521 /* Method for consolidating fix-it hints, for use by
2522 rich_location::maybe_add_fixit.
2523 If possible, merge a pending fix-it hint with the given params
2524 into this one and return true.
2525 Otherwise return false. */
2527 bool
2528 fixit_hint::maybe_append (location_t start,
2529 location_t next_loc,
2530 const char *new_content)
2532 /* For consolidation to be possible, START must be at this hint's
2533 m_next_loc. */
2534 if (start != m_next_loc)
2535 return false;
2537 /* If so, we have neighboring replacements; merge them. */
2538 m_next_loc = next_loc;
2539 size_t extra_len = strlen (new_content);
2540 m_bytes = (char *)xrealloc (m_bytes, m_len + extra_len + 1);
2541 memcpy (m_bytes + m_len, new_content, extra_len);
2542 m_len += extra_len;
2543 m_bytes[m_len] = '\0';
2544 return true;
2547 /* Return true iff this hint's content ends with a newline. */
2549 bool
2550 fixit_hint::ends_with_newline_p () const
2552 if (m_len == 0)
2553 return false;
2554 return m_bytes[m_len - 1] == '\n';