arm: Fix -mpure-code support/-mslow-flash-data for armv8-m.base [PR94538]
[gcc.git] / libcpp / line-map.c
1 /* Map (unsigned int) keys to (source file, line, column) triples.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3
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.
8
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.
13
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/>.
17
18 In other words, you are welcome to use, share and improve this program.
19 You are forbidden to forbid anyone else to use, share and improve
20 what you give them. Help stamp out software-hoarding! */
21
22 #include "config.h"
23 #include "system.h"
24 #include "line-map.h"
25 #include "cpplib.h"
26 #include "internal.h"
27 #include "hashtab.h"
28
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 **);
46
47 /* Counters defined in macro.c. */
48 extern unsigned num_expanded_macros_counter;
49 extern unsigned num_macro_tokens_counter;
50
51 /* Destructor for class line_maps.
52 Ensure non-GC-managed memory is released. */
53
54 line_maps::~line_maps ()
55 {
56 if (location_adhoc_data_map.htab)
57 htab_delete (location_adhoc_data_map.htab);
58 }
59
60 /* Hash function for location_adhoc_data hashtable. */
61
62 static hashval_t
63 location_adhoc_data_hash (const void *l)
64 {
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);
71 }
72
73 /* Compare function for location_adhoc_data hashtable. */
74
75 static int
76 location_adhoc_data_eq (const void *l1, const void *l2)
77 {
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);
86 }
87
88 /* Update the hashtable when location_adhoc_data is reallocated. */
89
90 static int
91 location_adhoc_data_update (void **slot, void *data)
92 {
93 *((char **) slot)
94 = (char *) ((uintptr_t) *((char **) slot) + *((ptrdiff_t *) data));
95 return 1;
96 }
97
98 /* Rebuild the hash table from the location adhoc data. */
99
100 void
101 rebuild_location_adhoc_htab (line_maps *set)
102 {
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);
109 }
110
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. */
114
115 static bool
116 can_be_stored_compactly_p (line_maps *set,
117 location_t locus,
118 source_range src_range,
119 void *data)
120 {
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;
125
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;
130
131 if (src_range.m_finish < src_range.m_start)
132 return false;
133
134 if (src_range.m_start < RESERVED_LOCATION_COUNT)
135 return false;
136
137 if (locus >= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
138 return false;
139
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;
149
150 /* Passed all tests. */
151 return true;
152 }
153
154 /* Combine LOCUS and DATA to a combined adhoc loc. */
155
156 location_t
157 get_combined_adhoc_loc (line_maps *set,
158 location_t locus,
159 source_range src_range,
160 void *data)
161 {
162 struct location_adhoc_data lb;
163 struct location_adhoc_data **slot;
164
165 if (IS_ADHOC_LOC (locus))
166 locus = get_location_from_adhoc_loc (set, locus);
167 if (locus == 0 && data == NULL)
168 return 0;
169
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));
176
177 /* Consider short-range optimization. */
178 if (can_be_stored_compactly_p (set, locus, src_range, data))
179 {
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))
187 {
188 location_t packed = locus | col_diff;
189 set->num_optimized_ranges++;
190 return packed;
191 }
192 }
193
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;
200
201 if (!data)
202 set->num_unoptimized_ranges++;
203
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)
210 {
211 if (set->location_adhoc_data_map.curr_loc >=
212 set->location_adhoc_data_map.allocated)
213 {
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);
220
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);
233 }
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;
238 }
239 return ((*slot) - set->location_adhoc_data_map.data) | 0x80000000;
240 }
241
242 /* Return the data for the adhoc loc. */
243
244 void *
245 get_data_from_adhoc_loc (const class line_maps *set, location_t loc)
246 {
247 linemap_assert (IS_ADHOC_LOC (loc));
248 return set->location_adhoc_data_map.data[loc & MAX_LOCATION_T].data;
249 }
250
251 /* Return the location for the adhoc loc. */
252
253 location_t
254 get_location_from_adhoc_loc (const class line_maps *set, location_t loc)
255 {
256 linemap_assert (IS_ADHOC_LOC (loc));
257 return set->location_adhoc_data_map.data[loc & MAX_LOCATION_T].locus;
258 }
259
260 /* Return the source_range for adhoc location LOC. */
261
262 static source_range
263 get_range_from_adhoc_loc (const class line_maps *set, location_t loc)
264 {
265 linemap_assert (IS_ADHOC_LOC (loc));
266 return set->location_adhoc_data_map.data[loc & MAX_LOCATION_T].src_range;
267 }
268
269 /* Get the source_range of location LOC, either from the ad-hoc
270 lookaside table, or embedded inside LOC itself. */
271
272 source_range
273 get_range_from_loc (line_maps *set,
274 location_t loc)
275 {
276 if (IS_ADHOC_LOC (loc))
277 return get_range_from_adhoc_loc (set, loc);
278
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)
283 {
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;
291 }
292
293 return source_range::from_location (loc);
294 }
295
296 /* Get whether location LOC is a "pure" location, or
297 whether it is an ad-hoc location, or embeds range information. */
298
299 bool
300 pure_location_p (line_maps *set, location_t loc)
301 {
302 if (IS_ADHOC_LOC (loc))
303 return false;
304
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);
309
310 if (loc & ((1U << ordmap->m_range_bits) - 1))
311 return false;
312
313 return true;
314 }
315
316 /* Given location LOC within SET, strip away any packed range information
317 or ad-hoc information. */
318
319 location_t
320 get_pure_location (line_maps *set, location_t loc)
321 {
322 if (IS_ADHOC_LOC (loc))
323 loc = get_location_from_adhoc_loc (set, loc);
324
325 if (loc >= LINEMAPS_MACRO_LOWEST_LOCATION (set))
326 return loc;
327
328 if (loc < RESERVED_LOCATION_COUNT)
329 return loc;
330
331 const line_map *map = linemap_lookup (set, loc);
332 const line_map_ordinary *ordmap = linemap_check_ordinary (map);
333
334 return loc & ~((1 << ordmap->m_range_bits) - 1);
335 }
336
337 /* Initialize a line map set. */
338
339 void
340 linemap_init (line_maps *set,
341 location_t builtin_location)
342 {
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;
356 }
357
358 /* Return the ordinary line map from whence MAP was included. Returns
359 NULL if MAP was not an include. */
360
361 const line_map_ordinary *
362 linemap_included_from_linemap (line_maps *set, const line_map_ordinary *map)
363 {
364 return linemap_ordinary_map_lookup (set, linemap_included_from (map));
365 }
366
367 /* Check for and warn about line_maps entered but not exited. */
368
369 void
370 linemap_check_files_exited (line_maps *set)
371 {
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));
379 }
380
381 /* Create a new line map in the line map set SET, and return it.
382 REASON is the reason of creating the map. It determines the type
383 of map created (ordinary or macro map). Note that ordinary maps and
384 macro maps are allocated in different memory location. */
385
386 static struct line_map *
387 new_linemap (line_maps *set, location_t start_location)
388 {
389 bool macro_p = start_location >= LINE_MAP_MAX_LOCATION;
390 unsigned num_maps_allocated = LINEMAPS_ALLOCATED (set, macro_p);
391 unsigned num_maps_used = LINEMAPS_USED (set, macro_p);
392
393 if (num_maps_used == num_maps_allocated)
394 {
395 /* We need more space! */
396 if (!num_maps_allocated)
397 num_maps_allocated = 128;
398 num_maps_allocated *= 2;
399
400 size_t size_of_a_map;
401 void *buffer;
402 if (macro_p)
403 {
404 size_of_a_map = sizeof (line_map_macro);
405 buffer = set->info_macro.maps;
406 }
407 else
408 {
409 size_of_a_map = sizeof (line_map_ordinary);
410 buffer = set->info_ordinary.maps;
411 }
412
413 /* We are going to execute some dance to try to reduce the
414 overhead of the memory allocator, in case we are using the
415 ggc-page.c one.
416
417 The actual size of memory we are going to get back from the
418 allocator may well be larger than what we ask for. Use this
419 hook to find what that size is. */
420 size_t alloc_size
421 = set->round_alloc_size (num_maps_allocated * size_of_a_map);
422
423 /* Now alloc_size contains the exact memory size we would get if
424 we have asked for the initial alloc_size amount of memory.
425 Let's get back to the number of map that amounts to. */
426 unsigned num_maps = alloc_size / size_of_a_map;
427 buffer = set->reallocator (buffer, num_maps * size_of_a_map);
428 memset ((char *)buffer + num_maps_used * size_of_a_map, 0,
429 (num_maps - num_maps_used) * size_of_a_map);
430 if (macro_p)
431 set->info_macro.maps = (line_map_macro *)buffer;
432 else
433 set->info_ordinary.maps = (line_map_ordinary *)buffer;
434 LINEMAPS_ALLOCATED (set, macro_p) = num_maps;
435 }
436
437 line_map *result = (macro_p ? (line_map *)&set->info_macro.maps[num_maps_used]
438 : (line_map *)&set->info_ordinary.maps[num_maps_used]);
439 LINEMAPS_USED (set, macro_p)++;
440
441 result->start_location = start_location;
442
443 return result;
444 }
445
446 /* Add a mapping of logical source line to physical source file and
447 line number.
448
449 The text pointed to by TO_FILE must have a lifetime
450 at least as long as the final call to lookup_line (). An empty
451 TO_FILE means standard input. If reason is LC_LEAVE, and
452 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
453 natural values considering the file we are returning to.
454
455 FROM_LINE should be monotonic increasing across calls to this
456 function. A call to this function can relocate the previous set of
457 maps, so any stored line_map pointers should not be used. */
458
459 const struct line_map *
460 linemap_add (line_maps *set, enum lc_reason reason,
461 unsigned int sysp, const char *to_file, linenum_type to_line)
462 {
463 /* Generate a start_location above the current highest_location.
464 If possible, make the low range bits be zero. */
465 location_t start_location = set->highest_location + 1;
466 unsigned range_bits = 0;
467 if (start_location < LINE_MAP_MAX_LOCATION_WITH_COLS)
468 range_bits = set->default_range_bits;
469 start_location += (1 << range_bits) - 1;
470 start_location &= ~((1 << range_bits) - 1);
471
472 linemap_assert (!LINEMAPS_ORDINARY_USED (set)
473 || (start_location
474 >= MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set))));
475
476 /* When we enter the file for the first time reason cannot be
477 LC_RENAME. */
478 linemap_assert (!(set->depth == 0 && reason == LC_RENAME));
479
480 /* If we are leaving the main file, return a NULL map. */
481 if (reason == LC_LEAVE
482 && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set))
483 && to_file == NULL)
484 {
485 set->depth--;
486 return NULL;
487 }
488
489 linemap_assert (reason != LC_ENTER_MACRO);
490
491 if (start_location >= LINE_MAP_MAX_LOCATION)
492 /* We ran out of line map space. */
493 start_location = 0;
494
495 line_map_ordinary *map
496 = linemap_check_ordinary (new_linemap (set, start_location));
497 map->reason = reason;
498
499 if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM)
500 to_file = "<stdin>";
501
502 if (reason == LC_RENAME_VERBATIM)
503 reason = LC_RENAME;
504
505 const line_map_ordinary *from = NULL;
506 if (reason == LC_LEAVE)
507 {
508 /* When we are just leaving an "included" file, and jump to the next
509 location inside the "includer" right after the #include
510 "included", this variable points the map in use right before the
511 #include "included", inside the same "includer" file. */
512
513 linemap_assert (!MAIN_FILE_P (map - 1));
514 /* (MAP - 1) points to the map we are leaving. The
515 map from which (MAP - 1) got included should be the map
516 that comes right before MAP in the same file. */
517 from = linemap_included_from_linemap (set, map - 1);
518
519 /* A TO_FILE of NULL is special - we use the natural values. */
520 if (to_file == NULL)
521 {
522 to_file = ORDINARY_MAP_FILE_NAME (from);
523 to_line = SOURCE_LINE (from, from[1].start_location);
524 sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (from);
525 }
526 else
527 linemap_assert (filename_cmp (ORDINARY_MAP_FILE_NAME (from),
528 to_file) == 0);
529 }
530
531 map->sysp = sysp;
532 map->to_file = to_file;
533 map->to_line = to_line;
534 LINEMAPS_ORDINARY_CACHE (set) = LINEMAPS_ORDINARY_USED (set) - 1;
535 /* Do not store range_bits here. That's readjusted in
536 linemap_line_start. */
537 map->m_range_bits = map->m_column_and_range_bits = 0;
538 set->highest_location = start_location;
539 set->highest_line = start_location;
540 set->max_column_hint = 0;
541
542 /* This assertion is placed after set->highest_location has
543 been updated, since the latter affects
544 linemap_location_from_macro_expansion_p, which ultimately affects
545 pure_location_p. */
546 linemap_assert (pure_location_p (set, start_location));
547
548 if (reason == LC_ENTER)
549 {
550 if (set->depth == 0)
551 map->included_from = 0;
552 else
553 /* The location of the end of the just-closed map. */
554 map->included_from
555 = (((map[0].start_location - 1 - map[-1].start_location)
556 & ~((1 << map[-1].m_column_and_range_bits) - 1))
557 + map[-1].start_location);
558 set->depth++;
559 if (set->trace_includes)
560 trace_include (set, map);
561 }
562 else if (reason == LC_RENAME)
563 map->included_from = linemap_included_from (&map[-1]);
564 else if (reason == LC_LEAVE)
565 {
566 set->depth--;
567 map->included_from = linemap_included_from (from);
568 }
569
570 return map;
571 }
572
573 /* Returns TRUE if the line table set tracks token locations across
574 macro expansion, FALSE otherwise. */
575
576 bool
577 linemap_tracks_macro_expansion_locs_p (line_maps *set)
578 {
579 return LINEMAPS_MACRO_MAPS (set) != NULL;
580 }
581
582 /* Create a macro map. A macro map encodes source locations of tokens
583 that are part of a macro replacement-list, at a macro expansion
584 point. See the extensive comments of struct line_map and struct
585 line_map_macro, in line-map.h.
586
587 This map shall be created when the macro is expanded. The map
588 encodes the source location of the expansion point of the macro as
589 well as the "original" source location of each token that is part
590 of the macro replacement-list. If a macro is defined but never
591 expanded, it has no macro map. SET is the set of maps the macro
592 map should be part of. MACRO_NODE is the macro which the new macro
593 map should encode source locations for. EXPANSION is the location
594 of the expansion point of MACRO. For function-like macros
595 invocations, it's best to make it point to the closing parenthesis
596 of the macro, rather than the the location of the first character
597 of the macro. NUM_TOKENS is the number of tokens that are part of
598 the replacement-list of MACRO.
599
600 Note that when we run out of the integer space available for source
601 locations, this function returns NULL. In that case, callers of
602 this function cannot encode {line,column} pairs into locations of
603 macro tokens anymore. */
604
605 const line_map_macro *
606 linemap_enter_macro (class line_maps *set, struct cpp_hashnode *macro_node,
607 location_t expansion, unsigned int num_tokens)
608 {
609 location_t start_location
610 = LINEMAPS_MACRO_LOWEST_LOCATION (set) - num_tokens;
611
612 if (start_location < LINE_MAP_MAX_LOCATION)
613 /* We ran out of macro map space. */
614 return NULL;
615
616 line_map_macro *map = linemap_check_macro (new_linemap (set, start_location));
617
618 map->macro = macro_node;
619 map->n_tokens = num_tokens;
620 map->macro_locations
621 = (location_t*) set->reallocator (NULL,
622 2 * num_tokens
623 * sizeof (location_t));
624 map->expansion = expansion;
625 memset (MACRO_MAP_LOCATIONS (map), 0,
626 2 * num_tokens * sizeof (location_t));
627
628 LINEMAPS_MACRO_CACHE (set) = LINEMAPS_MACRO_USED (set) - 1;
629
630 return map;
631 }
632
633 /* Create and return a virtual location for a token that is part of a
634 macro expansion-list at a macro expansion point. See the comment
635 inside struct line_map_macro to see what an expansion-list exactly
636 is.
637
638 A call to this function must come after a call to
639 linemap_enter_macro.
640
641 MAP is the map into which the source location is created. TOKEN_NO
642 is the index of the token in the macro replacement-list, starting
643 at number 0.
644
645 ORIG_LOC is the location of the token outside of this macro
646 expansion. If the token comes originally from the macro
647 definition, it is the locus in the macro definition; otherwise it
648 is a location in the context of the caller of this macro expansion
649 (which is a virtual location or a source location if the caller is
650 itself a macro expansion or not).
651
652 ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition,
653 either of the token itself or of a macro parameter that it
654 replaces. */
655
656 location_t
657 linemap_add_macro_token (const line_map_macro *map,
658 unsigned int token_no,
659 location_t orig_loc,
660 location_t orig_parm_replacement_loc)
661 {
662 location_t result;
663
664 linemap_assert (linemap_macro_expansion_map_p (map));
665 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
666
667 MACRO_MAP_LOCATIONS (map)[2 * token_no] = orig_loc;
668 MACRO_MAP_LOCATIONS (map)[2 * token_no + 1] = orig_parm_replacement_loc;
669
670 result = MAP_START_LOCATION (map) + token_no;
671 return result;
672 }
673
674 /* Return a location_t for the start (i.e. column==0) of
675 (physical) line TO_LINE in the current source file (as in the
676 most recent linemap_add). MAX_COLUMN_HINT is the highest column
677 number we expect to use in this line (but it does not change
678 the highest_location). */
679
680 location_t
681 linemap_line_start (line_maps *set, linenum_type to_line,
682 unsigned int max_column_hint)
683 {
684 line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
685 location_t highest = set->highest_location;
686 location_t r;
687 linenum_type last_line =
688 SOURCE_LINE (map, set->highest_line);
689 int line_delta = to_line - last_line;
690 bool add_map = false;
691 linemap_assert (map->m_column_and_range_bits >= map->m_range_bits);
692 int effective_column_bits = map->m_column_and_range_bits - map->m_range_bits;
693
694 if (line_delta < 0
695 || (line_delta > 10
696 && line_delta * map->m_column_and_range_bits > 1000)
697 || (max_column_hint >= (1U << effective_column_bits))
698 || (max_column_hint <= 80 && effective_column_bits >= 10)
699 || (highest > LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
700 && map->m_range_bits > 0)
701 || (highest > LINE_MAP_MAX_LOCATION_WITH_COLS
702 && (set->max_column_hint || highest >= LINE_MAP_MAX_LOCATION)))
703 add_map = true;
704 else
705 max_column_hint = set->max_column_hint;
706 if (add_map)
707 {
708 int column_bits;
709 int range_bits;
710 if (max_column_hint > LINE_MAP_MAX_COLUMN_NUMBER
711 || highest > LINE_MAP_MAX_LOCATION_WITH_COLS)
712 {
713 /* If the column number is ridiculous or we've allocated a huge
714 number of location_ts, give up on column numbers
715 (and on packed ranges). */
716 max_column_hint = 1;
717 column_bits = 0;
718 range_bits = 0;
719 if (highest >= LINE_MAP_MAX_LOCATION)
720 goto overflowed;
721 }
722 else
723 {
724 column_bits = 7;
725 if (highest <= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
726 range_bits = set->default_range_bits;
727 else
728 range_bits = 0;
729 while (max_column_hint >= (1U << column_bits))
730 column_bits++;
731 max_column_hint = 1U << column_bits;
732 column_bits += range_bits;
733 }
734
735 /* Allocate the new line_map. However, if the current map only has a
736 single line we can sometimes just increase its column_bits instead. */
737 if (line_delta < 0
738 || last_line != ORDINARY_MAP_STARTING_LINE_NUMBER (map)
739 || SOURCE_COLUMN (map, highest) >= (1U << (column_bits - range_bits))
740 || ( /* We can't reuse the map if the line offset is sufficiently
741 large to cause overflow when computing location_t values. */
742 (to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
743 >= (((uint64_t) 1)
744 << (CHAR_BIT * sizeof (linenum_type) - column_bits)))
745 || range_bits < map->m_range_bits)
746 map = linemap_check_ordinary
747 (const_cast <line_map *>
748 (linemap_add (set, LC_RENAME,
749 ORDINARY_MAP_IN_SYSTEM_HEADER_P (map),
750 ORDINARY_MAP_FILE_NAME (map),
751 to_line)));
752 map->m_column_and_range_bits = column_bits;
753 map->m_range_bits = range_bits;
754 r = (MAP_START_LOCATION (map)
755 + ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
756 << column_bits));
757 }
758 else
759 r = set->highest_line + (line_delta << map->m_column_and_range_bits);
760
761 /* Locations of ordinary tokens are always lower than locations of
762 macro tokens. */
763 if (r >= LINE_MAP_MAX_LOCATION)
764 {
765 overflowed:
766 /* Remember we overflowed. */
767 set->highest_line = set->highest_location = LINE_MAP_MAX_LOCATION - 1;
768 /* No column numbers! */
769 set->max_column_hint = 1;
770 return 0;
771 }
772
773 set->highest_line = r;
774 if (r > set->highest_location)
775 set->highest_location = r;
776 set->max_column_hint = max_column_hint;
777
778 /* At this point, we expect one of:
779 (a) the normal case: a "pure" location with 0 range bits, or
780 (b) we've gone past LINE_MAP_MAX_LOCATION_WITH_COLS so can't track
781 columns anymore (or ranges), or
782 (c) we're in a region with a column hint exceeding
783 LINE_MAP_MAX_COLUMN_NUMBER, so column-tracking is off,
784 with column_bits == 0. */
785 linemap_assert (pure_location_p (set, r)
786 || r >= LINE_MAP_MAX_LOCATION_WITH_COLS
787 || map->m_column_and_range_bits == 0);
788 linemap_assert (SOURCE_LINE (map, r) == to_line);
789 return r;
790 }
791
792 /* Encode and return a location_t from a column number. The
793 source line considered is the last source line used to call
794 linemap_line_start, i.e, the last source line which a location was
795 encoded from. */
796
797 location_t
798 linemap_position_for_column (line_maps *set, unsigned int to_column)
799 {
800 location_t r = set->highest_line;
801
802 linemap_assert
803 (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
804
805 if (to_column >= set->max_column_hint)
806 {
807 if (r > LINE_MAP_MAX_LOCATION_WITH_COLS
808 || to_column > LINE_MAP_MAX_COLUMN_NUMBER)
809 {
810 /* Running low on location_ts - disable column numbers. */
811 return r;
812 }
813 else
814 {
815 /* Otherwise, attempt to start a new line that can hold TO_COLUMN,
816 with some space to spare. This may or may not lead to a new
817 linemap being created. */
818 line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
819 r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
820 map = LINEMAPS_LAST_ORDINARY_MAP (set);
821 if (map->m_column_and_range_bits == 0)
822 {
823 /* ...then the linemap has column-tracking disabled,
824 presumably due to exceeding either
825 LINE_MAP_MAX_LOCATION_WITH_COLS (overall) or
826 LINE_MAP_MAX_COLUMN_NUMBER (within this line).
827 Return the start of the linemap, which encodes column 0, for
828 the whole line. */
829 return r;
830 }
831 }
832 }
833 line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
834 r = r + (to_column << map->m_range_bits);
835 if (r >= set->highest_location)
836 set->highest_location = r;
837 return r;
838 }
839
840 /* Encode and return a source location from a given line and
841 column. */
842
843 location_t
844 linemap_position_for_line_and_column (line_maps *set,
845 const line_map_ordinary *ord_map,
846 linenum_type line,
847 unsigned column)
848 {
849 linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map) <= line);
850
851 location_t r = MAP_START_LOCATION (ord_map);
852 r += ((line - ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map))
853 << ord_map->m_column_and_range_bits);
854 if (r <= LINE_MAP_MAX_LOCATION_WITH_COLS)
855 r += ((column & ((1 << ord_map->m_column_and_range_bits) - 1))
856 << ord_map->m_range_bits);
857 location_t upper_limit = LINEMAPS_MACRO_LOWEST_LOCATION (set);
858 if (r >= upper_limit)
859 r = upper_limit - 1;
860 if (r > set->highest_location)
861 set->highest_location = r;
862 return r;
863 }
864
865 /* Encode and return a location_t starting from location LOC and
866 shifting it by COLUMN_OFFSET columns. This function does not support
867 virtual locations. */
868
869 location_t
870 linemap_position_for_loc_and_offset (line_maps *set,
871 location_t loc,
872 unsigned int column_offset)
873 {
874 const line_map_ordinary * map = NULL;
875
876 if (IS_ADHOC_LOC (loc))
877 loc = get_location_from_adhoc_loc (set, loc);
878
879 /* This function does not support virtual locations yet. */
880 if (linemap_location_from_macro_expansion_p (set, loc))
881 return loc;
882
883 if (column_offset == 0
884 /* Adding an offset to a reserved location (like
885 UNKNOWN_LOCATION for the C/C++ FEs) does not really make
886 sense. So let's leave the location intact in that case. */
887 || loc < RESERVED_LOCATION_COUNT)
888 return loc;
889
890 /* We find the real location and shift it. */
891 loc = linemap_resolve_location (set, loc, LRK_SPELLING_LOCATION, &map);
892 /* The new location (loc + offset) should be higher than the first
893 location encoded by MAP. This can fail if the line information
894 is messed up because of line directives (see PR66415). */
895 if (MAP_START_LOCATION (map) >= loc + (column_offset << map->m_range_bits))
896 return loc;
897
898 linenum_type line = SOURCE_LINE (map, loc);
899 unsigned int column = SOURCE_COLUMN (map, loc);
900
901 /* If MAP is not the last line map of its set, then the new location
902 (loc + offset) should be less than the first location encoded by
903 the next line map of the set. Otherwise, we try to encode the
904 location in the next map. */
905 while (map != LINEMAPS_LAST_ORDINARY_MAP (set)
906 && (loc + (column_offset << map->m_range_bits)
907 >= MAP_START_LOCATION (&map[1])))
908 {
909 map = &map[1];
910 /* If the next map starts in a higher line, we cannot encode the
911 location there. */
912 if (line < ORDINARY_MAP_STARTING_LINE_NUMBER (map))
913 return loc;
914 }
915
916 column += column_offset;
917
918 /* Bail out if the column is not representable within the existing
919 linemap. */
920 if (column >= (1u << (map->m_column_and_range_bits - map->m_range_bits)))
921 return loc;
922
923 location_t r =
924 linemap_position_for_line_and_column (set, map, line, column);
925 if (linemap_assert_fails (r <= set->highest_location)
926 || linemap_assert_fails (map == linemap_lookup (set, r)))
927 return loc;
928
929 return r;
930 }
931
932 /* Given a virtual source location yielded by a map (either an
933 ordinary or a macro map), returns that map. */
934
935 const struct line_map*
936 linemap_lookup (const line_maps *set, location_t line)
937 {
938 if (IS_ADHOC_LOC (line))
939 line = get_location_from_adhoc_loc (set, line);
940 if (linemap_location_from_macro_expansion_p (set, line))
941 return linemap_macro_map_lookup (set, line);
942 return linemap_ordinary_map_lookup (set, line);
943 }
944
945 /* Given a source location yielded by an ordinary map, returns that
946 map. Since the set is built chronologically, the logical lines are
947 monotonic increasing, and so the list is sorted and we can use a
948 binary search. */
949
950 static const line_map_ordinary *
951 linemap_ordinary_map_lookup (const line_maps *set, location_t line)
952 {
953 if (IS_ADHOC_LOC (line))
954 line = get_location_from_adhoc_loc (set, line);
955
956 if (set == NULL || line < RESERVED_LOCATION_COUNT)
957 return NULL;
958
959 unsigned mn = LINEMAPS_ORDINARY_CACHE (set);
960 unsigned mx = LINEMAPS_ORDINARY_USED (set);
961
962 const line_map_ordinary *cached = LINEMAPS_ORDINARY_MAP_AT (set, mn);
963 /* We should get a segfault if no line_maps have been added yet. */
964 if (line >= MAP_START_LOCATION (cached))
965 {
966 if (mn + 1 == mx || line < MAP_START_LOCATION (&cached[1]))
967 return cached;
968 }
969 else
970 {
971 mx = mn;
972 mn = 0;
973 }
974
975 while (mx - mn > 1)
976 {
977 unsigned md = (mn + mx) / 2;
978 if (MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (set, md)) > line)
979 mx = md;
980 else
981 mn = md;
982 }
983
984 LINEMAPS_ORDINARY_CACHE (set) = mn;
985 const line_map_ordinary *result = LINEMAPS_ORDINARY_MAP_AT (set, mn);
986 linemap_assert (line >= MAP_START_LOCATION (result));
987 return result;
988 }
989
990 /* Given a source location yielded by a macro map, returns that map.
991 Since the set is built chronologically, the logical lines are
992 monotonic decreasing, and so the list is sorted and we can use a
993 binary search. */
994
995 static const line_map_macro *
996 linemap_macro_map_lookup (const line_maps *set, location_t line)
997 {
998 if (IS_ADHOC_LOC (line))
999 line = get_location_from_adhoc_loc (set, line);
1000
1001 linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set));
1002
1003 if (set == NULL)
1004 return NULL;
1005
1006 unsigned mn = LINEMAPS_MACRO_CACHE (set);
1007 unsigned mx = LINEMAPS_MACRO_USED (set);
1008 const struct line_map_macro *cached = LINEMAPS_MACRO_MAP_AT (set, mn);
1009
1010 if (line >= MAP_START_LOCATION (cached))
1011 {
1012 if (mn == 0 || line < MAP_START_LOCATION (&cached[-1]))
1013 return cached;
1014 mx = mn - 1;
1015 mn = 0;
1016 }
1017
1018 while (mn < mx)
1019 {
1020 unsigned md = (mx + mn) / 2;
1021 if (MAP_START_LOCATION (LINEMAPS_MACRO_MAP_AT (set, md)) > line)
1022 mn = md + 1;
1023 else
1024 mx = md;
1025 }
1026
1027 LINEMAPS_MACRO_CACHE (set) = mx;
1028 const struct line_map_macro *result = LINEMAPS_MACRO_MAP_AT (set, mx);
1029 linemap_assert (MAP_START_LOCATION (result) <= line);
1030
1031 return result;
1032 }
1033
1034 /* Return TRUE if MAP encodes locations coming from a macro
1035 replacement-list at macro expansion point. */
1036
1037 bool
1038 linemap_macro_expansion_map_p (const struct line_map *map)
1039 {
1040 return map && !MAP_ORDINARY_P (map);
1041 }
1042
1043 /* If LOCATION is the locus of a token in a replacement-list of a
1044 macro expansion return the location of the macro expansion point.
1045
1046 Read the comments of struct line_map and struct line_map_macro in
1047 line-map.h to understand what a macro expansion point is. */
1048
1049 static location_t
1050 linemap_macro_map_loc_to_exp_point (const line_map_macro *map,
1051 location_t location ATTRIBUTE_UNUSED)
1052 {
1053 linemap_assert (linemap_macro_expansion_map_p (map)
1054 && location >= MAP_START_LOCATION (map));
1055
1056 /* Make sure LOCATION is correct. */
1057 linemap_assert ((location - MAP_START_LOCATION (map))
1058 < MACRO_MAP_NUM_MACRO_TOKENS (map));
1059
1060 return MACRO_MAP_EXPANSION_POINT_LOCATION (map);
1061 }
1062
1063 /* LOCATION is the source location of a token that belongs to a macro
1064 replacement-list as part of the macro expansion denoted by MAP.
1065
1066 Return the location of the token at the definition point of the
1067 macro. */
1068
1069 static location_t
1070 linemap_macro_map_loc_to_def_point (const line_map_macro *map,
1071 location_t location)
1072 {
1073 unsigned token_no;
1074
1075 linemap_assert (linemap_macro_expansion_map_p (map)
1076 && location >= MAP_START_LOCATION (map));
1077 linemap_assert (location >= RESERVED_LOCATION_COUNT);
1078
1079 token_no = location - MAP_START_LOCATION (map);
1080 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
1081
1082 location = MACRO_MAP_LOCATIONS (map)[2 * token_no + 1];
1083
1084 return location;
1085 }
1086
1087 /* If LOCATION is the locus of a token that is an argument of a
1088 function-like macro M and appears in the expansion of M, return the
1089 locus of that argument in the context of the caller of M.
1090
1091 In other words, this returns the xI location presented in the
1092 comments of line_map_macro above. */
1093 location_t
1094 linemap_macro_map_loc_unwind_toward_spelling (line_maps *set,
1095 const line_map_macro* map,
1096 location_t location)
1097 {
1098 unsigned token_no;
1099
1100 if (IS_ADHOC_LOC (location))
1101 location = get_location_from_adhoc_loc (set, location);
1102
1103 linemap_assert (linemap_macro_expansion_map_p (map)
1104 && location >= MAP_START_LOCATION (map));
1105 linemap_assert (location >= RESERVED_LOCATION_COUNT);
1106 linemap_assert (!IS_ADHOC_LOC (location));
1107
1108 token_no = location - MAP_START_LOCATION (map);
1109 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
1110
1111 location = MACRO_MAP_LOCATIONS (map)[2 * token_no];
1112
1113 return location;
1114 }
1115
1116 /* Return the source line number corresponding to source location
1117 LOCATION. SET is the line map set LOCATION comes from. If
1118 LOCATION is the source location of token that is part of the
1119 replacement-list of a macro expansion return the line number of the
1120 macro expansion point. */
1121
1122 int
1123 linemap_get_expansion_line (line_maps *set,
1124 location_t location)
1125 {
1126 const line_map_ordinary *map = NULL;
1127
1128 if (IS_ADHOC_LOC (location))
1129 location = get_location_from_adhoc_loc (set, location);
1130
1131 if (location < RESERVED_LOCATION_COUNT)
1132 return 0;
1133
1134 location =
1135 linemap_macro_loc_to_exp_point (set, location, &map);
1136
1137 return SOURCE_LINE (map, location);
1138 }
1139
1140 /* Return the path of the file corresponding to source code location
1141 LOCATION.
1142
1143 If LOCATION is the source location of token that is part of the
1144 replacement-list of a macro expansion return the file path of the
1145 macro expansion point.
1146
1147 SET is the line map set LOCATION comes from. */
1148
1149 const char*
1150 linemap_get_expansion_filename (line_maps *set,
1151 location_t location)
1152 {
1153 const struct line_map_ordinary *map = NULL;
1154
1155 if (IS_ADHOC_LOC (location))
1156 location = get_location_from_adhoc_loc (set, location);
1157
1158 if (location < RESERVED_LOCATION_COUNT)
1159 return NULL;
1160
1161 linemap_macro_loc_to_exp_point (set, location, &map);
1162
1163 return LINEMAP_FILE (map);
1164 }
1165
1166 /* Return the name of the macro associated to MACRO_MAP. */
1167
1168 const char*
1169 linemap_map_get_macro_name (const line_map_macro *macro_map)
1170 {
1171 linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map));
1172 return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map));
1173 }
1174
1175 /* Return a positive value if LOCATION is the locus of a token that is
1176 located in a system header, O otherwise. It returns 1 if LOCATION
1177 is the locus of a token that is located in a system header, and 2
1178 if LOCATION is the locus of a token located in a C system header
1179 that therefore needs to be extern "C" protected in C++.
1180
1181 Note that this function returns 1 if LOCATION belongs to a token
1182 that is part of a macro replacement-list defined in a system
1183 header, but expanded in a non-system file. */
1184
1185 int
1186 linemap_location_in_system_header_p (line_maps *set,
1187 location_t location)
1188 {
1189 const struct line_map *map = NULL;
1190
1191 if (IS_ADHOC_LOC (location))
1192 location = get_location_from_adhoc_loc (set, location);
1193
1194 if (location < RESERVED_LOCATION_COUNT)
1195 return false;
1196
1197 /* Let's look at where the token for LOCATION comes from. */
1198 while (true)
1199 {
1200 map = linemap_lookup (set, location);
1201 if (map != NULL)
1202 {
1203 if (!linemap_macro_expansion_map_p (map))
1204 /* It's a normal token. */
1205 return LINEMAP_SYSP (linemap_check_ordinary (map));
1206 else
1207 {
1208 const line_map_macro *macro_map = linemap_check_macro (map);
1209
1210 /* It's a token resulting from a macro expansion. */
1211 location_t loc =
1212 linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, location);
1213 if (loc < RESERVED_LOCATION_COUNT)
1214 /* This token might come from a built-in macro. Let's
1215 look at where that macro got expanded. */
1216 location = linemap_macro_map_loc_to_exp_point (macro_map, location);
1217 else
1218 location = loc;
1219 }
1220 }
1221 else
1222 break;
1223 }
1224 return false;
1225 }
1226
1227 /* Return TRUE if LOCATION is a source code location of a token that is part of
1228 a macro expansion, FALSE otherwise. */
1229
1230 bool
1231 linemap_location_from_macro_expansion_p (const class line_maps *set,
1232 location_t location)
1233 {
1234 if (IS_ADHOC_LOC (location))
1235 location = get_location_from_adhoc_loc (set, location);
1236
1237 return IS_MACRO_LOC (location);
1238 }
1239
1240 /* Given two virtual locations *LOC0 and *LOC1, return the first
1241 common macro map in their macro expansion histories. Return NULL
1242 if no common macro was found. *LOC0 (resp. *LOC1) is set to the
1243 virtual location of the token inside the resulting macro. */
1244
1245 static const struct line_map*
1246 first_map_in_common_1 (line_maps *set,
1247 location_t *loc0,
1248 location_t *loc1)
1249 {
1250 location_t l0 = *loc0, l1 = *loc1;
1251 const struct line_map *map0 = linemap_lookup (set, l0);
1252 if (IS_ADHOC_LOC (l0))
1253 l0 = get_location_from_adhoc_loc (set, l0);
1254
1255 const struct line_map *map1 = linemap_lookup (set, l1);
1256 if (IS_ADHOC_LOC (l1))
1257 l1 = get_location_from_adhoc_loc (set, l1);
1258
1259 while (linemap_macro_expansion_map_p (map0)
1260 && linemap_macro_expansion_map_p (map1)
1261 && (map0 != map1))
1262 {
1263 if (MAP_START_LOCATION (map0) < MAP_START_LOCATION (map1))
1264 {
1265 l0 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map0),
1266 l0);
1267 map0 = linemap_lookup (set, l0);
1268 }
1269 else
1270 {
1271 l1 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map1),
1272 l1);
1273 map1 = linemap_lookup (set, l1);
1274 }
1275 }
1276
1277 if (map0 == map1)
1278 {
1279 *loc0 = l0;
1280 *loc1 = l1;
1281 return map0;
1282 }
1283 return NULL;
1284 }
1285
1286 /* Given two virtual locations LOC0 and LOC1, return the first common
1287 macro map in their macro expansion histories. Return NULL if no
1288 common macro was found. *RES_LOC0 (resp. *RES_LOC1) is set to the
1289 virtual location of the token inside the resulting macro, upon
1290 return of a non-NULL result. */
1291
1292 static const struct line_map*
1293 first_map_in_common (line_maps *set,
1294 location_t loc0,
1295 location_t loc1,
1296 location_t *res_loc0,
1297 location_t *res_loc1)
1298 {
1299 *res_loc0 = loc0;
1300 *res_loc1 = loc1;
1301
1302 return first_map_in_common_1 (set, res_loc0, res_loc1);
1303 }
1304
1305 /* Return a positive value if PRE denotes the location of a token that
1306 comes before the token of POST, 0 if PRE denotes the location of
1307 the same token as the token for POST, and a negative value
1308 otherwise. */
1309
1310 int
1311 linemap_compare_locations (line_maps *set,
1312 location_t pre,
1313 location_t post)
1314 {
1315 bool pre_virtual_p, post_virtual_p;
1316 location_t l0 = pre, l1 = post;
1317
1318 if (IS_ADHOC_LOC (l0))
1319 l0 = get_location_from_adhoc_loc (set, l0);
1320 if (IS_ADHOC_LOC (l1))
1321 l1 = get_location_from_adhoc_loc (set, l1);
1322
1323 if (l0 == l1)
1324 return 0;
1325
1326 if ((pre_virtual_p = linemap_location_from_macro_expansion_p (set, l0)))
1327 l0 = linemap_resolve_location (set, l0,
1328 LRK_MACRO_EXPANSION_POINT,
1329 NULL);
1330
1331 if ((post_virtual_p = linemap_location_from_macro_expansion_p (set, l1)))
1332 l1 = linemap_resolve_location (set, l1,
1333 LRK_MACRO_EXPANSION_POINT,
1334 NULL);
1335
1336 if (l0 == l1
1337 && pre_virtual_p
1338 && post_virtual_p)
1339 {
1340 /* So pre and post represent two tokens that are present in a
1341 same macro expansion. Let's see if the token for pre was
1342 before the token for post in that expansion. */
1343 unsigned i0, i1;
1344 const struct line_map *map =
1345 first_map_in_common (set, pre, post, &l0, &l1);
1346
1347 if (map == NULL)
1348 /* This should not be possible. */
1349 abort ();
1350
1351 i0 = l0 - MAP_START_LOCATION (map);
1352 i1 = l1 - MAP_START_LOCATION (map);
1353 return i1 - i0;
1354 }
1355
1356 if (IS_ADHOC_LOC (l0))
1357 l0 = get_location_from_adhoc_loc (set, l0);
1358 if (IS_ADHOC_LOC (l1))
1359 l1 = get_location_from_adhoc_loc (set, l1);
1360
1361 return l1 - l0;
1362 }
1363
1364 /* Print an include trace, for e.g. the -H option of the preprocessor. */
1365
1366 static void
1367 trace_include (const class line_maps *set, const line_map_ordinary *map)
1368 {
1369 unsigned int i = set->depth;
1370
1371 while (--i)
1372 putc ('.', stderr);
1373
1374 fprintf (stderr, " %s\n", ORDINARY_MAP_FILE_NAME (map));
1375 }
1376
1377 /* Return the spelling location of the token wherever it comes from,
1378 whether part of a macro definition or not.
1379
1380 This is a subroutine for linemap_resolve_location. */
1381
1382 static location_t
1383 linemap_macro_loc_to_spelling_point (line_maps *set,
1384 location_t location,
1385 const line_map_ordinary **original_map)
1386 {
1387 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1388
1389 while (true)
1390 {
1391 const struct line_map *map = linemap_lookup (set, location);
1392 if (!map || MAP_ORDINARY_P (map))
1393 {
1394 if (original_map)
1395 *original_map = (const line_map_ordinary *)map;
1396 break;
1397 }
1398
1399 location = linemap_macro_map_loc_unwind_toward_spelling
1400 (set, linemap_check_macro (map), location);
1401 }
1402
1403 return location;
1404 }
1405
1406 /* If LOCATION is the source location of a token that belongs to a
1407 macro replacement-list -- as part of a macro expansion -- then
1408 return the location of the token at the definition point of the
1409 macro. Otherwise, return LOCATION. SET is the set of maps
1410 location come from. ORIGINAL_MAP is an output parm. If non NULL,
1411 the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
1412 returned location comes from.
1413
1414 This is a subroutine of linemap_resolve_location. */
1415
1416 static location_t
1417 linemap_macro_loc_to_def_point (line_maps *set,
1418 location_t location,
1419 const line_map_ordinary **original_map)
1420 {
1421 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1422
1423 for (;;)
1424 {
1425 location_t caret_loc = location;
1426 if (IS_ADHOC_LOC (caret_loc))
1427 caret_loc = get_location_from_adhoc_loc (set, caret_loc);
1428
1429 const line_map *map = linemap_lookup (set, caret_loc);
1430 if (!map || MAP_ORDINARY_P (map))
1431 {
1432 if (original_map)
1433 *original_map = (const line_map_ordinary *)map;
1434 break;
1435 }
1436
1437 location = linemap_macro_map_loc_to_def_point
1438 (linemap_check_macro (map), caret_loc);
1439 }
1440
1441 return location;
1442 }
1443
1444 /* If LOCATION is the source location of a token that belongs to a
1445 macro replacement-list -- at a macro expansion point -- then return
1446 the location of the topmost expansion point of the macro. We say
1447 topmost because if we are in the context of a nested macro
1448 expansion, the function returns the source location of the first
1449 macro expansion that triggered the nested expansions.
1450
1451 Otherwise, return LOCATION. SET is the set of maps location come
1452 from. ORIGINAL_MAP is an output parm. If non NULL, the function
1453 sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
1454 location comes from.
1455
1456 This is a subroutine of linemap_resolve_location. */
1457
1458 static location_t
1459 linemap_macro_loc_to_exp_point (line_maps *set,
1460 location_t location,
1461 const line_map_ordinary **original_map)
1462 {
1463 struct line_map *map;
1464
1465 if (IS_ADHOC_LOC (location))
1466 location = get_location_from_adhoc_loc (set, location);
1467
1468 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1469
1470 while (true)
1471 {
1472 map = const_cast <line_map *> (linemap_lookup (set, location));
1473 if (!linemap_macro_expansion_map_p (map))
1474 break;
1475 location = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map),
1476 location);
1477 }
1478
1479 if (original_map)
1480 *original_map = linemap_check_ordinary (map);
1481 return location;
1482 }
1483
1484 /* Resolve a virtual location into either a spelling location, an
1485 expansion point location or a token argument replacement point
1486 location. Return the map that encodes the virtual location as well
1487 as the resolved location.
1488
1489 If LOC is *NOT* the location of a token resulting from the
1490 expansion of a macro, then the parameter LRK (which stands for
1491 Location Resolution Kind) is ignored and the resulting location
1492 just equals the one given in argument.
1493
1494 Now if LOC *IS* the location of a token resulting from the
1495 expansion of a macro, this is what happens.
1496
1497 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1498 -------------------------------
1499
1500 The virtual location is resolved to the first macro expansion point
1501 that led to this macro expansion.
1502
1503 * If LRK is set to LRK_SPELLING_LOCATION
1504 -------------------------------------
1505
1506 The virtual location is resolved to the locus where the token has
1507 been spelled in the source. This can follow through all the macro
1508 expansions that led to the token.
1509
1510 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1511 --------------------------------------
1512
1513 The virtual location is resolved to the locus of the token in the
1514 context of the macro definition.
1515
1516 If LOC is the locus of a token that is an argument of a
1517 function-like macro [replacing a parameter in the replacement list
1518 of the macro] the virtual location is resolved to the locus of the
1519 parameter that is replaced, in the context of the definition of the
1520 macro.
1521
1522 If LOC is the locus of a token that is not an argument of a
1523 function-like macro, then the function behaves as if LRK was set to
1524 LRK_SPELLING_LOCATION.
1525
1526 If MAP is not NULL, *MAP is set to the map encoding the
1527 returned location. Note that if the returned location wasn't originally
1528 encoded by a map, then *MAP is set to NULL. This can happen if LOC
1529 resolves to a location reserved for the client code, like
1530 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1531
1532 location_t
1533 linemap_resolve_location (line_maps *set,
1534 location_t loc,
1535 enum location_resolution_kind lrk,
1536 const line_map_ordinary **map)
1537 {
1538 location_t locus = loc;
1539 if (IS_ADHOC_LOC (loc))
1540 locus = get_location_from_adhoc_loc (set, loc);
1541
1542 if (locus < RESERVED_LOCATION_COUNT)
1543 {
1544 /* A reserved location wasn't encoded in a map. Let's return a
1545 NULL map here, just like what linemap_ordinary_map_lookup
1546 does. */
1547 if (map)
1548 *map = NULL;
1549 return loc;
1550 }
1551
1552 switch (lrk)
1553 {
1554 case LRK_MACRO_EXPANSION_POINT:
1555 loc = linemap_macro_loc_to_exp_point (set, loc, map);
1556 break;
1557 case LRK_SPELLING_LOCATION:
1558 loc = linemap_macro_loc_to_spelling_point (set, loc, map);
1559 break;
1560 case LRK_MACRO_DEFINITION_LOCATION:
1561 loc = linemap_macro_loc_to_def_point (set, loc, map);
1562 break;
1563 default:
1564 abort ();
1565 }
1566 return loc;
1567 }
1568
1569 /* TRUE if LOCATION is a source code location of a token that is part of the
1570 definition of a macro, FALSE otherwise. */
1571
1572 bool
1573 linemap_location_from_macro_definition_p (line_maps *set,
1574 location_t loc)
1575 {
1576 if (IS_ADHOC_LOC (loc))
1577 loc = get_location_from_adhoc_loc (set, loc);
1578
1579 if (!linemap_location_from_macro_expansion_p (set, loc))
1580 return false;
1581
1582 while (true)
1583 {
1584 const struct line_map_macro *map
1585 = linemap_check_macro (linemap_lookup (set, loc));
1586
1587 location_t s_loc
1588 = linemap_macro_map_loc_unwind_toward_spelling (set, map, loc);
1589 if (linemap_location_from_macro_expansion_p (set, s_loc))
1590 loc = s_loc;
1591 else
1592 {
1593 location_t def_loc
1594 = linemap_macro_map_loc_to_def_point (map, loc);
1595 return s_loc == def_loc;
1596 }
1597 }
1598 }
1599
1600 /*
1601 Suppose that LOC is the virtual location of a token T coming from
1602 the expansion of a macro M. This function then steps up to get the
1603 location L of the point where M got expanded. If L is a spelling
1604 location inside a macro expansion M', then this function returns
1605 the locus of the point where M' was expanded. Said otherwise, this
1606 function returns the location of T in the context that triggered
1607 the expansion of M.
1608
1609 *LOC_MAP must be set to the map of LOC. This function then sets it
1610 to the map of the returned location. */
1611
1612 location_t
1613 linemap_unwind_toward_expansion (line_maps *set,
1614 location_t loc,
1615 const struct line_map **map)
1616 {
1617 location_t resolved_location;
1618 const line_map_macro *macro_map = linemap_check_macro (*map);
1619 const struct line_map *resolved_map;
1620
1621 if (IS_ADHOC_LOC (loc))
1622 loc = get_location_from_adhoc_loc (set, loc);
1623
1624 resolved_location =
1625 linemap_macro_map_loc_unwind_toward_spelling (set, macro_map, loc);
1626 resolved_map = linemap_lookup (set, resolved_location);
1627
1628 if (!linemap_macro_expansion_map_p (resolved_map))
1629 {
1630 resolved_location = linemap_macro_map_loc_to_exp_point (macro_map, loc);
1631 resolved_map = linemap_lookup (set, resolved_location);
1632 }
1633
1634 *map = resolved_map;
1635 return resolved_location;
1636 }
1637
1638 /* If LOC is the virtual location of a token coming from the expansion
1639 of a macro M and if its spelling location is reserved (e.g, a
1640 location for a built-in token), then this function unwinds (using
1641 linemap_unwind_toward_expansion) the location until a location that
1642 is not reserved and is not in a system header is reached. In other
1643 words, this unwinds the reserved location until a location that is
1644 in real source code is reached.
1645
1646 Otherwise, if the spelling location for LOC is not reserved or if
1647 LOC doesn't come from the expansion of a macro, the function
1648 returns LOC as is and *MAP is not touched.
1649
1650 *MAP is set to the map of the returned location if the later is
1651 different from LOC. */
1652 location_t
1653 linemap_unwind_to_first_non_reserved_loc (line_maps *set,
1654 location_t loc,
1655 const struct line_map **map)
1656 {
1657 location_t resolved_loc;
1658 const struct line_map *map0 = NULL;
1659 const line_map_ordinary *map1 = NULL;
1660
1661 if (IS_ADHOC_LOC (loc))
1662 loc = get_location_from_adhoc_loc (set, loc);
1663
1664 map0 = linemap_lookup (set, loc);
1665 if (!linemap_macro_expansion_map_p (map0))
1666 return loc;
1667
1668 resolved_loc = linemap_resolve_location (set, loc,
1669 LRK_SPELLING_LOCATION,
1670 &map1);
1671
1672 if (resolved_loc >= RESERVED_LOCATION_COUNT
1673 && !LINEMAP_SYSP (map1))
1674 return loc;
1675
1676 while (linemap_macro_expansion_map_p (map0)
1677 && (resolved_loc < RESERVED_LOCATION_COUNT
1678 || LINEMAP_SYSP (map1)))
1679 {
1680 loc = linemap_unwind_toward_expansion (set, loc, &map0);
1681 resolved_loc = linemap_resolve_location (set, loc,
1682 LRK_SPELLING_LOCATION,
1683 &map1);
1684 }
1685
1686 if (map != NULL)
1687 *map = map0;
1688 return loc;
1689 }
1690
1691 /* Expand source code location LOC and return a user readable source
1692 code location. LOC must be a spelling (non-virtual) location. If
1693 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1694 location is returned. */
1695
1696 expanded_location
1697 linemap_expand_location (line_maps *set,
1698 const struct line_map *map,
1699 location_t loc)
1700
1701 {
1702 expanded_location xloc;
1703
1704 memset (&xloc, 0, sizeof (xloc));
1705 if (IS_ADHOC_LOC (loc))
1706 {
1707 xloc.data = get_data_from_adhoc_loc (set, loc);
1708 loc = get_location_from_adhoc_loc (set, loc);
1709 }
1710
1711 if (loc < RESERVED_LOCATION_COUNT)
1712 /* The location for this token wasn't generated from a line map.
1713 It was probably a location for a builtin token, chosen by some
1714 client code. Let's not try to expand the location in that
1715 case. */;
1716 else if (map == NULL)
1717 /* We shouldn't be getting a NULL map with a location that is not
1718 reserved by the client code. */
1719 abort ();
1720 else
1721 {
1722 /* MAP must be an ordinary map and LOC must be non-virtual,
1723 encoded into this map, obviously; the accessors used on MAP
1724 below ensure it is ordinary. Let's just assert the
1725 non-virtualness of LOC here. */
1726 if (linemap_location_from_macro_expansion_p (set, loc))
1727 abort ();
1728
1729 const line_map_ordinary *ord_map = linemap_check_ordinary (map);
1730
1731 xloc.file = LINEMAP_FILE (ord_map);
1732 xloc.line = SOURCE_LINE (ord_map, loc);
1733 xloc.column = SOURCE_COLUMN (ord_map, loc);
1734 xloc.sysp = LINEMAP_SYSP (ord_map) != 0;
1735 }
1736
1737 return xloc;
1738 }
1739
1740
1741 /* Dump line map at index IX in line table SET to STREAM. If STREAM
1742 is NULL, use stderr. IS_MACRO is true if the caller wants to
1743 dump a macro map, false otherwise. */
1744
1745 void
1746 linemap_dump (FILE *stream, class line_maps *set, unsigned ix, bool is_macro)
1747 {
1748 const char *const lc_reasons_v[LC_HWM]
1749 = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
1750 "LC_ENTER_MACRO" };
1751 const line_map *map;
1752 unsigned reason;
1753
1754 if (stream == NULL)
1755 stream = stderr;
1756
1757 if (!is_macro)
1758 {
1759 map = LINEMAPS_ORDINARY_MAP_AT (set, ix);
1760 reason = linemap_check_ordinary (map)->reason;
1761 }
1762 else
1763 {
1764 map = LINEMAPS_MACRO_MAP_AT (set, ix);
1765 reason = LC_ENTER_MACRO;
1766 }
1767
1768 fprintf (stream, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
1769 ix, (void *) map, map->start_location,
1770 reason < LC_HWM ? lc_reasons_v[reason] : "???",
1771 ((!is_macro
1772 && ORDINARY_MAP_IN_SYSTEM_HEADER_P (linemap_check_ordinary (map)))
1773 ? "yes" : "no"));
1774 if (!is_macro)
1775 {
1776 const line_map_ordinary *ord_map = linemap_check_ordinary (map);
1777 const line_map_ordinary *includer_map
1778 = linemap_included_from_linemap (set, ord_map);
1779
1780 fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map),
1781 ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map));
1782 fprintf (stream, "Included from: [%d] %s\n",
1783 includer_map ? int (includer_map - set->info_ordinary.maps) : -1,
1784 includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None");
1785 }
1786 else
1787 {
1788 const line_map_macro *macro_map = linemap_check_macro (map);
1789 fprintf (stream, "Macro: %s (%u tokens)\n",
1790 linemap_map_get_macro_name (macro_map),
1791 MACRO_MAP_NUM_MACRO_TOKENS (macro_map));
1792 }
1793
1794 fprintf (stream, "\n");
1795 }
1796
1797
1798 /* Dump debugging information about source location LOC into the file
1799 stream STREAM. SET is the line map set LOC comes from. */
1800
1801 void
1802 linemap_dump_location (line_maps *set,
1803 location_t loc,
1804 FILE *stream)
1805 {
1806 const line_map_ordinary *map;
1807 location_t location;
1808 const char *path = "", *from = "";
1809 int l = -1, c = -1, s = -1, e = -1;
1810
1811 if (IS_ADHOC_LOC (loc))
1812 loc = get_location_from_adhoc_loc (set, loc);
1813
1814 if (loc == 0)
1815 return;
1816
1817 location =
1818 linemap_resolve_location (set, loc, LRK_MACRO_DEFINITION_LOCATION, &map);
1819
1820 if (map == NULL)
1821 /* Only reserved locations can be tolerated in this case. */
1822 linemap_assert (location < RESERVED_LOCATION_COUNT);
1823 else
1824 {
1825 path = LINEMAP_FILE (map);
1826 l = SOURCE_LINE (map, location);
1827 c = SOURCE_COLUMN (map, location);
1828 s = LINEMAP_SYSP (map) != 0;
1829 e = location != loc;
1830 if (e)
1831 from = "N/A";
1832 else
1833 {
1834 const line_map_ordinary *from_map
1835 = linemap_included_from_linemap (set, map);
1836 from = from_map ? LINEMAP_FILE (from_map) : "<NULL>";
1837 }
1838 }
1839
1840 /* P: path, L: line, C: column, S: in-system-header, M: map address,
1841 E: macro expansion?, LOC: original location, R: resolved location */
1842 fprintf (stream, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}",
1843 path, from, l, c, s, (void*)map, e, loc, location);
1844 }
1845
1846 /* Return the highest location emitted for a given file for which
1847 there is a line map in SET. FILE_NAME is the file name to
1848 consider. If the function returns TRUE, *LOC is set to the highest
1849 location emitted for that file. */
1850
1851 bool
1852 linemap_get_file_highest_location (line_maps *set,
1853 const char *file_name,
1854 location_t *loc)
1855 {
1856 /* If the set is empty or no ordinary map has been created then
1857 there is no file to look for ... */
1858 if (set == NULL || set->info_ordinary.used == 0)
1859 return false;
1860
1861 /* Now look for the last ordinary map created for FILE_NAME. */
1862 int i;
1863 for (i = set->info_ordinary.used - 1; i >= 0; --i)
1864 {
1865 const char *fname = set->info_ordinary.maps[i].to_file;
1866 if (fname && !filename_cmp (fname, file_name))
1867 break;
1868 }
1869
1870 if (i < 0)
1871 return false;
1872
1873 /* The highest location for a given map is either the starting
1874 location of the next map minus one, or -- if the map is the
1875 latest one -- the highest location of the set. */
1876 location_t result;
1877 if (i == (int) set->info_ordinary.used - 1)
1878 result = set->highest_location;
1879 else
1880 result = set->info_ordinary.maps[i + 1].start_location - 1;
1881
1882 *loc = result;
1883 return true;
1884 }
1885
1886 /* Compute and return statistics about the memory consumption of some
1887 parts of the line table SET. */
1888
1889 void
1890 linemap_get_statistics (line_maps *set,
1891 struct linemap_stats *s)
1892 {
1893 long ordinary_maps_allocated_size, ordinary_maps_used_size,
1894 macro_maps_allocated_size, macro_maps_used_size,
1895 macro_maps_locations_size = 0, duplicated_macro_maps_locations_size = 0;
1896
1897 const line_map_macro *cur_map;
1898
1899 ordinary_maps_allocated_size =
1900 LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map_ordinary);
1901
1902 ordinary_maps_used_size =
1903 LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map_ordinary);
1904
1905 macro_maps_allocated_size =
1906 LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map_macro);
1907
1908 for (cur_map = LINEMAPS_MACRO_MAPS (set);
1909 cur_map && cur_map <= LINEMAPS_LAST_MACRO_MAP (set);
1910 ++cur_map)
1911 {
1912 unsigned i;
1913
1914 linemap_assert (linemap_macro_expansion_map_p (cur_map));
1915
1916 macro_maps_locations_size +=
1917 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map) * sizeof (location_t);
1918
1919 for (i = 0; i < 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map); i += 2)
1920 {
1921 if (MACRO_MAP_LOCATIONS (cur_map)[i] ==
1922 MACRO_MAP_LOCATIONS (cur_map)[i + 1])
1923 duplicated_macro_maps_locations_size +=
1924 sizeof (location_t);
1925 }
1926 }
1927
1928 macro_maps_used_size =
1929 LINEMAPS_MACRO_USED (set) * sizeof (struct line_map_macro);
1930
1931 s->num_ordinary_maps_allocated = LINEMAPS_ORDINARY_ALLOCATED (set);
1932 s->num_ordinary_maps_used = LINEMAPS_ORDINARY_USED (set);
1933 s->ordinary_maps_allocated_size = ordinary_maps_allocated_size;
1934 s->ordinary_maps_used_size = ordinary_maps_used_size;
1935 s->num_expanded_macros = num_expanded_macros_counter;
1936 s->num_macro_tokens = num_macro_tokens_counter;
1937 s->num_macro_maps_used = LINEMAPS_MACRO_USED (set);
1938 s->macro_maps_allocated_size = macro_maps_allocated_size;
1939 s->macro_maps_locations_size = macro_maps_locations_size;
1940 s->macro_maps_used_size = macro_maps_used_size;
1941 s->duplicated_macro_maps_locations_size =
1942 duplicated_macro_maps_locations_size;
1943 s->adhoc_table_size = (set->location_adhoc_data_map.allocated
1944 * sizeof (struct location_adhoc_data));
1945 s->adhoc_table_entries_used = set->location_adhoc_data_map.curr_loc;
1946 }
1947
1948
1949 /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
1950 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
1951 specifies how many macro maps to dump. */
1952
1953 void
1954 line_table_dump (FILE *stream, class line_maps *set, unsigned int num_ordinary,
1955 unsigned int num_macro)
1956 {
1957 unsigned int i;
1958
1959 if (set == NULL)
1960 return;
1961
1962 if (stream == NULL)
1963 stream = stderr;
1964
1965 fprintf (stream, "# of ordinary maps: %d\n", LINEMAPS_ORDINARY_USED (set));
1966 fprintf (stream, "# of macro maps: %d\n", LINEMAPS_MACRO_USED (set));
1967 fprintf (stream, "Include stack depth: %d\n", set->depth);
1968 fprintf (stream, "Highest location: %u\n", set->highest_location);
1969
1970 if (num_ordinary)
1971 {
1972 fprintf (stream, "\nOrdinary line maps\n");
1973 for (i = 0; i < num_ordinary && i < LINEMAPS_ORDINARY_USED (set); i++)
1974 linemap_dump (stream, set, i, false);
1975 fprintf (stream, "\n");
1976 }
1977
1978 if (num_macro)
1979 {
1980 fprintf (stream, "\nMacro line maps\n");
1981 for (i = 0; i < num_macro && i < LINEMAPS_MACRO_USED (set); i++)
1982 linemap_dump (stream, set, i, true);
1983 fprintf (stream, "\n");
1984 }
1985 }
1986
1987 /* class rich_location. */
1988
1989 /* Construct a rich_location with location LOC as its initial range. */
1990
1991 rich_location::rich_location (line_maps *set, location_t loc,
1992 const range_label *label) :
1993 m_line_table (set),
1994 m_ranges (),
1995 m_column_override (0),
1996 m_have_expanded_location (false),
1997 m_fixit_hints (),
1998 m_seen_impossible_fixit (false),
1999 m_fixits_cannot_be_auto_applied (false),
2000 m_path (NULL)
2001 {
2002 add_range (loc, SHOW_RANGE_WITH_CARET, label);
2003 }
2004
2005 /* The destructor for class rich_location. */
2006
2007 rich_location::~rich_location ()
2008 {
2009 for (unsigned int i = 0; i < m_fixit_hints.count (); i++)
2010 delete get_fixit_hint (i);
2011 }
2012
2013 /* Get location IDX within this rich_location. */
2014
2015 location_t
2016 rich_location::get_loc (unsigned int idx) const
2017 {
2018 const location_range *locrange = get_range (idx);
2019 return locrange->m_loc;
2020 }
2021
2022 /* Get range IDX within this rich_location. */
2023
2024 const location_range *
2025 rich_location::get_range (unsigned int idx) const
2026 {
2027 return &m_ranges[idx];
2028 }
2029
2030 /* Mutable access to range IDX within this rich_location. */
2031
2032 location_range *
2033 rich_location::get_range (unsigned int idx)
2034 {
2035 return &m_ranges[idx];
2036 }
2037
2038 /* Expand location IDX within this rich_location. */
2039 /* Get an expanded_location for this rich_location's primary
2040 location. */
2041
2042 expanded_location
2043 rich_location::get_expanded_location (unsigned int idx)
2044 {
2045 if (idx == 0)
2046 {
2047 /* Cache the expansion of the primary location. */
2048 if (!m_have_expanded_location)
2049 {
2050 m_expanded_location
2051 = linemap_client_expand_location_to_spelling_point
2052 (get_loc (0), LOCATION_ASPECT_CARET);
2053 if (m_column_override)
2054 m_expanded_location.column = m_column_override;
2055 m_have_expanded_location = true;
2056 }
2057
2058 return m_expanded_location;
2059 }
2060 else
2061 return linemap_client_expand_location_to_spelling_point
2062 (get_loc (idx), LOCATION_ASPECT_CARET);
2063 }
2064
2065 /* Set the column of the primary location, with 0 meaning
2066 "don't override it". */
2067
2068 void
2069 rich_location::override_column (int column)
2070 {
2071 m_column_override = column;
2072 m_have_expanded_location = false;
2073 }
2074
2075 /* Add the given range. */
2076
2077 void
2078 rich_location::add_range (location_t loc,
2079 enum range_display_kind range_display_kind,
2080 const range_label *label)
2081 {
2082 location_range range;
2083 range.m_loc = loc;
2084 range.m_range_display_kind = range_display_kind;
2085 range.m_label = label;
2086 m_ranges.push (range);
2087 }
2088
2089 /* Add or overwrite the location given by IDX, setting its location to LOC,
2090 and setting its m_range_display_kind to RANGE_DISPLAY_KIND.
2091
2092 It must either overwrite an existing location, or add one *exactly* on
2093 the end of the array.
2094
2095 This is primarily for use by gcc when implementing diagnostic format
2096 decoders e.g.
2097 - the "+" in the C/C++ frontends, for handling format codes like "%q+D"
2098 (which writes the source location of a tree back into location 0 of
2099 the rich_location), and
2100 - the "%C" and "%L" format codes in the Fortran frontend. */
2101
2102 void
2103 rich_location::set_range (unsigned int idx, location_t loc,
2104 enum range_display_kind range_display_kind)
2105 {
2106 /* We can either overwrite an existing range, or add one exactly
2107 on the end of the array. */
2108 linemap_assert (idx <= m_ranges.count ());
2109
2110 if (idx == m_ranges.count ())
2111 add_range (loc, range_display_kind);
2112 else
2113 {
2114 location_range *locrange = get_range (idx);
2115 locrange->m_loc = loc;
2116 locrange->m_range_display_kind = range_display_kind;
2117 }
2118
2119 if (idx == 0)
2120 /* Mark any cached value here as dirty. */
2121 m_have_expanded_location = false;
2122 }
2123
2124 /* Methods for adding insertion fix-it hints. */
2125
2126 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2127 immediately before the primary range's start location. */
2128
2129 void
2130 rich_location::add_fixit_insert_before (const char *new_content)
2131 {
2132 add_fixit_insert_before (get_loc (), new_content);
2133 }
2134
2135 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2136 immediately before the start of WHERE. */
2137
2138 void
2139 rich_location::add_fixit_insert_before (location_t where,
2140 const char *new_content)
2141 {
2142 location_t start = get_range_from_loc (m_line_table, where).m_start;
2143 maybe_add_fixit (start, start, new_content);
2144 }
2145
2146 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2147 immediately after the primary range's end-point. */
2148
2149 void
2150 rich_location::add_fixit_insert_after (const char *new_content)
2151 {
2152 add_fixit_insert_after (get_loc (), new_content);
2153 }
2154
2155 /* Add a fixit-hint, suggesting insertion of NEW_CONTENT
2156 immediately after the end-point of WHERE. */
2157
2158 void
2159 rich_location::add_fixit_insert_after (location_t where,
2160 const char *new_content)
2161 {
2162 location_t finish = get_range_from_loc (m_line_table, where).m_finish;
2163 location_t next_loc
2164 = linemap_position_for_loc_and_offset (m_line_table, finish, 1);
2165
2166 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2167 its input value. */
2168 if (next_loc == finish)
2169 {
2170 stop_supporting_fixits ();
2171 return;
2172 }
2173
2174 maybe_add_fixit (next_loc, next_loc, new_content);
2175 }
2176
2177 /* Methods for adding removal fix-it hints. */
2178
2179 /* Add a fixit-hint, suggesting removal of the content covered
2180 by range 0. */
2181
2182 void
2183 rich_location::add_fixit_remove ()
2184 {
2185 add_fixit_remove (get_loc ());
2186 }
2187
2188 /* Add a fixit-hint, suggesting removal of the content between
2189 the start and finish of WHERE. */
2190
2191 void
2192 rich_location::add_fixit_remove (location_t where)
2193 {
2194 source_range range = get_range_from_loc (m_line_table, where);
2195 add_fixit_remove (range);
2196 }
2197
2198 /* Add a fixit-hint, suggesting removal of the content at
2199 SRC_RANGE. */
2200
2201 void
2202 rich_location::add_fixit_remove (source_range src_range)
2203 {
2204 add_fixit_replace (src_range, "");
2205 }
2206
2207 /* Add a fixit-hint, suggesting replacement of the content covered
2208 by range 0 with NEW_CONTENT. */
2209
2210 void
2211 rich_location::add_fixit_replace (const char *new_content)
2212 {
2213 add_fixit_replace (get_loc (), new_content);
2214 }
2215
2216 /* Methods for adding "replace" fix-it hints. */
2217
2218 /* Add a fixit-hint, suggesting replacement of the content between
2219 the start and finish of WHERE with NEW_CONTENT. */
2220
2221 void
2222 rich_location::add_fixit_replace (location_t where,
2223 const char *new_content)
2224 {
2225 source_range range = get_range_from_loc (m_line_table, where);
2226 add_fixit_replace (range, new_content);
2227 }
2228
2229 /* Add a fixit-hint, suggesting replacement of the content at
2230 SRC_RANGE with NEW_CONTENT. */
2231
2232 void
2233 rich_location::add_fixit_replace (source_range src_range,
2234 const char *new_content)
2235 {
2236 location_t start = get_pure_location (m_line_table, src_range.m_start);
2237 location_t finish = get_pure_location (m_line_table, src_range.m_finish);
2238
2239 /* Fix-it hints use half-closed ranges, so attempt to offset the endpoint. */
2240 location_t next_loc
2241 = linemap_position_for_loc_and_offset (m_line_table, finish, 1);
2242 /* linemap_position_for_loc_and_offset can fail, if so, it returns
2243 its input value. */
2244 if (next_loc == finish)
2245 {
2246 stop_supporting_fixits ();
2247 return;
2248 }
2249 finish = next_loc;
2250
2251 maybe_add_fixit (start, finish, new_content);
2252 }
2253
2254 /* Get the last fix-it hint within this rich_location, or NULL if none. */
2255
2256 fixit_hint *
2257 rich_location::get_last_fixit_hint () const
2258 {
2259 if (m_fixit_hints.count () > 0)
2260 return get_fixit_hint (m_fixit_hints.count () - 1);
2261 else
2262 return NULL;
2263 }
2264
2265 /* If WHERE is an "awkward" location, then mark this rich_location as not
2266 supporting fixits, purging any thay were already added, and return true.
2267
2268 Otherwise (the common case), return false. */
2269
2270 bool
2271 rich_location::reject_impossible_fixit (location_t where)
2272 {
2273 /* Fix-its within a rich_location should either all be suggested, or
2274 none of them should be suggested.
2275 Once we've rejected a fixit, we reject any more, even those
2276 with reasonable locations. */
2277 if (m_seen_impossible_fixit)
2278 return true;
2279
2280 if (where <= LINE_MAP_MAX_LOCATION_WITH_COLS)
2281 /* WHERE is a reasonable location for a fix-it; don't reject it. */
2282 return false;
2283
2284 /* Otherwise we have an attempt to add a fix-it with an "awkward"
2285 location: either one that we can't obtain column information
2286 for (within an ordinary map), or one within a macro expansion. */
2287 stop_supporting_fixits ();
2288 return true;
2289 }
2290
2291 /* Mark this rich_location as not supporting fixits, purging any that were
2292 already added. */
2293
2294 void
2295 rich_location::stop_supporting_fixits ()
2296 {
2297 m_seen_impossible_fixit = true;
2298
2299 /* Purge the rich_location of any fix-its that were already added. */
2300 for (unsigned int i = 0; i < m_fixit_hints.count (); i++)
2301 delete get_fixit_hint (i);
2302 m_fixit_hints.truncate (0);
2303 }
2304
2305 /* Add HINT to the fix-it hints in this rich_location,
2306 consolidating into the prior fixit if possible. */
2307
2308 void
2309 rich_location::maybe_add_fixit (location_t start,
2310 location_t next_loc,
2311 const char *new_content)
2312 {
2313 if (reject_impossible_fixit (start))
2314 return;
2315 if (reject_impossible_fixit (next_loc))
2316 return;
2317
2318 /* Only allow fix-it hints that affect a single line in one file.
2319 Compare the end-points. */
2320 expanded_location exploc_start
2321 = linemap_client_expand_location_to_spelling_point (start,
2322 LOCATION_ASPECT_START);
2323 expanded_location exploc_next_loc
2324 = linemap_client_expand_location_to_spelling_point (next_loc,
2325 LOCATION_ASPECT_START);
2326 /* They must be within the same file... */
2327 if (exploc_start.file != exploc_next_loc.file)
2328 {
2329 stop_supporting_fixits ();
2330 return;
2331 }
2332 /* ...and on the same line. */
2333 if (exploc_start.line != exploc_next_loc.line)
2334 {
2335 stop_supporting_fixits ();
2336 return;
2337 }
2338 /* The columns must be in the correct order. This can fail if the
2339 endpoints straddle the boundary for which the linemap can represent
2340 columns (PR c/82050). */
2341 if (exploc_start.column > exploc_next_loc.column)
2342 {
2343 stop_supporting_fixits ();
2344 return;
2345 }
2346
2347 const char *newline = strchr (new_content, '\n');
2348 if (newline)
2349 {
2350 /* For now, we can only support insertion of whole lines
2351 i.e. starts at start of line, and the newline is at the end of
2352 the insertion point. */
2353
2354 /* It must be an insertion, not a replacement/deletion. */
2355 if (start != next_loc)
2356 {
2357 stop_supporting_fixits ();
2358 return;
2359 }
2360
2361 /* The insertion must be at the start of a line. */
2362 if (exploc_start.column != 1)
2363 {
2364 stop_supporting_fixits ();
2365 return;
2366 }
2367
2368 /* The newline must be at end of NEW_CONTENT.
2369 We could eventually split up fix-its at newlines if we wanted
2370 to allow more generality (e.g. to allow adding multiple lines
2371 with one add_fixit call. */
2372 if (newline[1] != '\0')
2373 {
2374 stop_supporting_fixits ();
2375 return;
2376 }
2377 }
2378
2379 /* Consolidate neighboring fixits.
2380 Don't consolidate into newline-insertion fixits. */
2381 fixit_hint *prev = get_last_fixit_hint ();
2382 if (prev && !prev->ends_with_newline_p ())
2383 if (prev->maybe_append (start, next_loc, new_content))
2384 return;
2385
2386 m_fixit_hints.push (new fixit_hint (start, next_loc, new_content));
2387 }
2388
2389 /* class fixit_hint. */
2390
2391 fixit_hint::fixit_hint (location_t start,
2392 location_t next_loc,
2393 const char *new_content)
2394 : m_start (start),
2395 m_next_loc (next_loc),
2396 m_bytes (xstrdup (new_content)),
2397 m_len (strlen (new_content))
2398 {
2399 }
2400
2401 /* Does this fix-it hint affect the given line? */
2402
2403 bool
2404 fixit_hint::affects_line_p (const char *file, int line) const
2405 {
2406 expanded_location exploc_start
2407 = linemap_client_expand_location_to_spelling_point (m_start,
2408 LOCATION_ASPECT_START);
2409 if (file != exploc_start.file)
2410 return false;
2411 if (line < exploc_start.line)
2412 return false;
2413 expanded_location exploc_next_loc
2414 = linemap_client_expand_location_to_spelling_point (m_next_loc,
2415 LOCATION_ASPECT_START);
2416 if (file != exploc_next_loc.file)
2417 return false;
2418 if (line > exploc_next_loc.line)
2419 return false;
2420 return true;
2421 }
2422
2423 /* Method for consolidating fix-it hints, for use by
2424 rich_location::maybe_add_fixit.
2425 If possible, merge a pending fix-it hint with the given params
2426 into this one and return true.
2427 Otherwise return false. */
2428
2429 bool
2430 fixit_hint::maybe_append (location_t start,
2431 location_t next_loc,
2432 const char *new_content)
2433 {
2434 /* For consolidation to be possible, START must be at this hint's
2435 m_next_loc. */
2436 if (start != m_next_loc)
2437 return false;
2438
2439 /* If so, we have neighboring replacements; merge them. */
2440 m_next_loc = next_loc;
2441 size_t extra_len = strlen (new_content);
2442 m_bytes = (char *)xrealloc (m_bytes, m_len + extra_len + 1);
2443 memcpy (m_bytes + m_len, new_content, extra_len);
2444 m_len += extra_len;
2445 m_bytes[m_len] = '\0';
2446 return true;
2447 }
2448
2449 /* Return true iff this hint's content ends with a newline. */
2450
2451 bool
2452 fixit_hint::ends_with_newline_p () const
2453 {
2454 if (m_len == 0)
2455 return false;
2456 return m_bytes[m_len - 1] == '\n';
2457 }