Daily bump.
[official-gcc.git] / libcpp / line-map.c
bloba4055c29c740c8ac7bc7b42cca8338bc29d2f94b
1 /* Map logical line numbers to (source file, line number) pairs.
2 Copyright (C) 2001-2014 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 struct line_maps *, const struct line_map *);
30 static const struct line_map * linemap_ordinary_map_lookup (struct line_maps *,
31 source_location);
32 static const struct line_map* linemap_macro_map_lookup (struct line_maps *,
33 source_location);
34 static source_location linemap_macro_map_loc_to_def_point
35 (const struct line_map*, source_location);
36 static source_location linemap_macro_map_loc_unwind_toward_spelling
37 (const struct line_map*, source_location);
38 static source_location linemap_macro_map_loc_to_exp_point
39 (const struct line_map*, source_location);
40 static source_location linemap_macro_loc_to_spelling_point
41 (struct line_maps *, source_location, const struct line_map **);
42 static source_location linemap_macro_loc_to_def_point (struct line_maps *,
43 source_location,
44 const struct line_map **);
45 static source_location linemap_macro_loc_to_exp_point (struct line_maps *,
46 source_location,
47 const struct line_map **);
49 /* Counters defined in macro.c. */
50 extern unsigned num_expanded_macros_counter;
51 extern unsigned num_macro_tokens_counter;
53 /* Hash function for location_adhoc_data hashtable. */
55 static hashval_t
56 location_adhoc_data_hash (const void *l)
58 const struct location_adhoc_data *lb =
59 (const struct location_adhoc_data *) l;
60 return (hashval_t) lb->locus + (size_t) lb->data;
63 /* Compare function for location_adhoc_data hashtable. */
65 static int
66 location_adhoc_data_eq (const void *l1, const void *l2)
68 const struct location_adhoc_data *lb1 =
69 (const struct location_adhoc_data *) l1;
70 const struct location_adhoc_data *lb2 =
71 (const struct location_adhoc_data *) l2;
72 return lb1->locus == lb2->locus && lb1->data == lb2->data;
75 /* Update the hashtable when location_adhoc_data is reallocated. */
77 static int
78 location_adhoc_data_update (void **slot, void *data)
80 *((char **) slot) += *((long long *) data);
81 return 1;
84 /* Rebuild the hash table from the location adhoc data. */
86 void
87 rebuild_location_adhoc_htab (struct line_maps *set)
89 unsigned i;
90 set->location_adhoc_data_map.htab =
91 htab_create (100, location_adhoc_data_hash, location_adhoc_data_eq, NULL);
92 for (i = 0; i < set->location_adhoc_data_map.curr_loc; i++)
93 htab_find_slot (set->location_adhoc_data_map.htab,
94 set->location_adhoc_data_map.data + i, INSERT);
97 /* Combine LOCUS and DATA to a combined adhoc loc. */
99 source_location
100 get_combined_adhoc_loc (struct line_maps *set,
101 source_location locus, void *data)
103 struct location_adhoc_data lb;
104 struct location_adhoc_data **slot;
106 linemap_assert (data);
108 if (IS_ADHOC_LOC (locus))
109 locus
110 = set->location_adhoc_data_map.data[locus & MAX_SOURCE_LOCATION].locus;
111 if (locus == 0 && data == NULL)
112 return 0;
113 lb.locus = locus;
114 lb.data = data;
115 slot = (struct location_adhoc_data **)
116 htab_find_slot (set->location_adhoc_data_map.htab, &lb, INSERT);
117 if (*slot == NULL)
119 if (set->location_adhoc_data_map.curr_loc >=
120 set->location_adhoc_data_map.allocated)
122 char *orig_data = (char *) set->location_adhoc_data_map.data;
123 long long offset;
124 /* Cast away extern "C" from the type of xrealloc. */
125 line_map_realloc reallocator = (set->reallocator
126 ? set->reallocator
127 : (line_map_realloc) xrealloc);
129 if (set->location_adhoc_data_map.allocated == 0)
130 set->location_adhoc_data_map.allocated = 128;
131 else
132 set->location_adhoc_data_map.allocated *= 2;
133 set->location_adhoc_data_map.data = (struct location_adhoc_data *)
134 reallocator (set->location_adhoc_data_map.data,
135 set->location_adhoc_data_map.allocated
136 * sizeof (struct location_adhoc_data));
137 offset = (char *) (set->location_adhoc_data_map.data) - orig_data;
138 if (set->location_adhoc_data_map.allocated > 128)
139 htab_traverse (set->location_adhoc_data_map.htab,
140 location_adhoc_data_update, &offset);
142 *slot = set->location_adhoc_data_map.data
143 + set->location_adhoc_data_map.curr_loc;
144 set->location_adhoc_data_map.data[set->location_adhoc_data_map.curr_loc++]
145 = lb;
147 return ((*slot) - set->location_adhoc_data_map.data) | 0x80000000;
150 /* Return the data for the adhoc loc. */
152 void *
153 get_data_from_adhoc_loc (struct line_maps *set, source_location loc)
155 linemap_assert (IS_ADHOC_LOC (loc));
156 return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
159 /* Return the location for the adhoc loc. */
161 source_location
162 get_location_from_adhoc_loc (struct line_maps *set, source_location loc)
164 linemap_assert (IS_ADHOC_LOC (loc));
165 return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
168 /* Finalize the location_adhoc_data structure. */
169 void
170 location_adhoc_data_fini (struct line_maps *set)
172 htab_delete (set->location_adhoc_data_map.htab);
175 /* Initialize a line map set. */
177 void
178 linemap_init (struct line_maps *set,
179 source_location builtin_location)
181 memset (set, 0, sizeof (struct line_maps));
182 set->highest_location = RESERVED_LOCATION_COUNT - 1;
183 set->highest_line = RESERVED_LOCATION_COUNT - 1;
184 set->location_adhoc_data_map.htab =
185 htab_create (100, location_adhoc_data_hash, location_adhoc_data_eq, NULL);
186 set->builtin_location = builtin_location;
189 /* Check for and warn about line_maps entered but not exited. */
191 void
192 linemap_check_files_exited (struct line_maps *set)
194 struct line_map *map;
195 /* Depending upon whether we are handling preprocessed input or
196 not, this can be a user error or an ICE. */
197 for (map = LINEMAPS_LAST_ORDINARY_MAP (set);
198 ! MAIN_FILE_P (map);
199 map = INCLUDED_FROM (set, map))
200 fprintf (stderr, "line-map.c: file \"%s\" entered but not left\n",
201 ORDINARY_MAP_FILE_NAME (map));
204 /* Create a new line map in the line map set SET, and return it.
205 REASON is the reason of creating the map. It determines the type
206 of map created (ordinary or macro map). Note that ordinary maps and
207 macro maps are allocated in different memory location. */
209 static struct line_map *
210 new_linemap (struct line_maps *set,
211 enum lc_reason reason)
213 /* Depending on this variable, a macro map would be allocated in a
214 different memory location than an ordinary map. */
215 bool macro_map_p = (reason == LC_ENTER_MACRO);
216 struct line_map *result;
218 if (LINEMAPS_USED (set, macro_map_p) == LINEMAPS_ALLOCATED (set, macro_map_p))
220 /* We ran out of allocated line maps. Let's allocate more. */
221 unsigned alloc_size;
223 /* Cast away extern "C" from the type of xrealloc. */
224 line_map_realloc reallocator = (set->reallocator
225 ? set->reallocator
226 : (line_map_realloc) xrealloc);
227 line_map_round_alloc_size_func round_alloc_size =
228 set->round_alloc_size;
230 /* We are going to execute some dance to try to reduce the
231 overhead of the memory allocator, in case we are using the
232 ggc-page.c one.
234 The actual size of memory we are going to get back from the
235 allocator is the smallest power of 2 that is greater than the
236 size we requested. So let's consider that size then. */
238 alloc_size =
239 (2 * LINEMAPS_ALLOCATED (set, macro_map_p) + 256)
240 * sizeof (struct line_map);
242 /* Get the actual size of memory that is going to be allocated
243 by the allocator. */
244 alloc_size = round_alloc_size (alloc_size);
246 /* Now alloc_size contains the exact memory size we would get if
247 we have asked for the initial alloc_size amount of memory.
248 Let's get back to the number of macro map that amounts
249 to. */
250 LINEMAPS_ALLOCATED (set, macro_map_p) =
251 alloc_size / (sizeof (struct line_map));
253 /* And now let's really do the re-allocation. */
254 LINEMAPS_MAPS (set, macro_map_p) =
255 (struct line_map *) (*reallocator)
256 (LINEMAPS_MAPS (set, macro_map_p),
257 (LINEMAPS_ALLOCATED (set, macro_map_p)
258 * sizeof (struct line_map)));
260 result =
261 &LINEMAPS_MAPS (set, macro_map_p)[LINEMAPS_USED (set, macro_map_p)];
262 memset (result, 0,
263 ((LINEMAPS_ALLOCATED (set, macro_map_p)
264 - LINEMAPS_USED (set, macro_map_p))
265 * sizeof (struct line_map)));
267 else
268 result =
269 &LINEMAPS_MAPS (set, macro_map_p)[LINEMAPS_USED (set, macro_map_p)];
271 LINEMAPS_USED (set, macro_map_p)++;
273 result->reason = reason;
274 return result;
277 /* Add a mapping of logical source line to physical source file and
278 line number.
280 The text pointed to by TO_FILE must have a lifetime
281 at least as long as the final call to lookup_line (). An empty
282 TO_FILE means standard input. If reason is LC_LEAVE, and
283 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
284 natural values considering the file we are returning to.
286 FROM_LINE should be monotonic increasing across calls to this
287 function. A call to this function can relocate the previous set of
288 maps, so any stored line_map pointers should not be used. */
290 const struct line_map *
291 linemap_add (struct line_maps *set, enum lc_reason reason,
292 unsigned int sysp, const char *to_file, linenum_type to_line)
294 struct line_map *map;
295 source_location start_location = set->highest_location + 1;
297 linemap_assert (!(LINEMAPS_ORDINARY_USED (set)
298 && (start_location
299 < MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set)))));
301 /* When we enter the file for the first time reason cannot be
302 LC_RENAME. */
303 linemap_assert (!(set->depth == 0 && reason == LC_RENAME));
305 /* If we are leaving the main file, return a NULL map. */
306 if (reason == LC_LEAVE
307 && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set))
308 && to_file == NULL)
310 set->depth--;
311 return NULL;
314 map = new_linemap (set, reason);
316 if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM)
317 to_file = "<stdin>";
319 if (reason == LC_RENAME_VERBATIM)
320 reason = LC_RENAME;
322 if (reason == LC_LEAVE)
324 /* When we are just leaving an "included" file, and jump to the next
325 location inside the "includer" right after the #include
326 "included", this variable points the map in use right before the
327 #include "included", inside the same "includer" file. */
328 struct line_map *from;
329 bool error;
331 if (MAIN_FILE_P (map - 1))
333 /* So this _should_ means we are leaving the main file --
334 effectively ending the compilation unit. But to_file not
335 being NULL means the caller thinks we are leaving to
336 another file. This is an erroneous behaviour but we'll
337 try to recover from it. Let's pretend we are not leaving
338 the main file. */
339 error = true;
340 reason = LC_RENAME;
341 from = map - 1;
343 else
345 /* (MAP - 1) points to the map we are leaving. The
346 map from which (MAP - 1) got included should be the map
347 that comes right before MAP in the same file. */
348 from = INCLUDED_FROM (set, map - 1);
349 error = to_file && filename_cmp (ORDINARY_MAP_FILE_NAME (from),
350 to_file);
353 /* Depending upon whether we are handling preprocessed input or
354 not, this can be a user error or an ICE. */
355 if (error)
356 fprintf (stderr, "line-map.c: file \"%s\" left but not entered\n",
357 to_file);
359 /* A TO_FILE of NULL is special - we use the natural values. */
360 if (error || to_file == NULL)
362 to_file = ORDINARY_MAP_FILE_NAME (from);
363 to_line = SOURCE_LINE (from, from[1].start_location);
364 sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (from);
368 linemap_assert (reason != LC_ENTER_MACRO);
369 ORDINARY_MAP_IN_SYSTEM_HEADER_P (map) = sysp;
370 MAP_START_LOCATION (map) = start_location;
371 ORDINARY_MAP_FILE_NAME (map) = to_file;
372 ORDINARY_MAP_STARTING_LINE_NUMBER (map) = to_line;
373 LINEMAPS_ORDINARY_CACHE (set) = LINEMAPS_ORDINARY_USED (set) - 1;
374 ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) = 0;
375 set->highest_location = start_location;
376 set->highest_line = start_location;
377 set->max_column_hint = 0;
379 if (reason == LC_ENTER)
381 ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
382 set->depth == 0 ? -1 : (int) (LINEMAPS_ORDINARY_USED (set) - 2);
383 set->depth++;
384 if (set->trace_includes)
385 trace_include (set, map);
387 else if (reason == LC_RENAME)
388 ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
389 ORDINARY_MAP_INCLUDER_FILE_INDEX (&map[-1]);
390 else if (reason == LC_LEAVE)
392 set->depth--;
393 ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
394 ORDINARY_MAP_INCLUDER_FILE_INDEX (INCLUDED_FROM (set, map - 1));
397 return map;
400 /* Returns TRUE if the line table set tracks token locations across
401 macro expansion, FALSE otherwise. */
403 bool
404 linemap_tracks_macro_expansion_locs_p (struct line_maps *set)
406 return LINEMAPS_MACRO_MAPS (set) != NULL;
409 /* Create a macro map. A macro map encodes source locations of tokens
410 that are part of a macro replacement-list, at a macro expansion
411 point. See the extensive comments of struct line_map and struct
412 line_map_macro, in line-map.h.
414 This map shall be created when the macro is expanded. The map
415 encodes the source location of the expansion point of the macro as
416 well as the "original" source location of each token that is part
417 of the macro replacement-list. If a macro is defined but never
418 expanded, it has no macro map. SET is the set of maps the macro
419 map should be part of. MACRO_NODE is the macro which the new macro
420 map should encode source locations for. EXPANSION is the location
421 of the expansion point of MACRO. For function-like macros
422 invocations, it's best to make it point to the closing parenthesis
423 of the macro, rather than the the location of the first character
424 of the macro. NUM_TOKENS is the number of tokens that are part of
425 the replacement-list of MACRO.
427 Note that when we run out of the integer space available for source
428 locations, this function returns NULL. In that case, callers of
429 this function cannot encode {line,column} pairs into locations of
430 macro tokens anymore. */
432 const struct line_map *
433 linemap_enter_macro (struct line_maps *set, struct cpp_hashnode *macro_node,
434 source_location expansion, unsigned int num_tokens)
436 struct line_map *map;
437 source_location start_location;
438 /* Cast away extern "C" from the type of xrealloc. */
439 line_map_realloc reallocator = (set->reallocator
440 ? set->reallocator
441 : (line_map_realloc) xrealloc);
443 start_location = LINEMAPS_MACRO_LOWEST_LOCATION (set) - num_tokens;
445 if (start_location <= set->highest_line
446 || start_location > LINEMAPS_MACRO_LOWEST_LOCATION (set))
447 /* We ran out of macro map space. */
448 return NULL;
450 map = new_linemap (set, LC_ENTER_MACRO);
452 MAP_START_LOCATION (map) = start_location;
453 MACRO_MAP_MACRO (map) = macro_node;
454 MACRO_MAP_NUM_MACRO_TOKENS (map) = num_tokens;
455 MACRO_MAP_LOCATIONS (map)
456 = (source_location*) reallocator (NULL,
457 2 * num_tokens
458 * sizeof (source_location));
459 MACRO_MAP_EXPANSION_POINT_LOCATION (map) = expansion;
460 memset (MACRO_MAP_LOCATIONS (map), 0,
461 num_tokens * sizeof (source_location));
463 LINEMAPS_MACRO_CACHE (set) = LINEMAPS_MACRO_USED (set) - 1;
465 return map;
468 /* Create and return a virtual location for a token that is part of a
469 macro expansion-list at a macro expansion point. See the comment
470 inside struct line_map_macro to see what an expansion-list exactly
473 A call to this function must come after a call to
474 linemap_enter_macro.
476 MAP is the map into which the source location is created. TOKEN_NO
477 is the index of the token in the macro replacement-list, starting
478 at number 0.
480 ORIG_LOC is the location of the token outside of this macro
481 expansion. If the token comes originally from the macro
482 definition, it is the locus in the macro definition; otherwise it
483 is a location in the context of the caller of this macro expansion
484 (which is a virtual location or a source location if the caller is
485 itself a macro expansion or not).
487 MACRO_DEFINITION_LOC is the location in the macro definition,
488 either of the token itself or of a macro parameter that it
489 replaces. */
491 source_location
492 linemap_add_macro_token (const struct line_map *map,
493 unsigned int token_no,
494 source_location orig_loc,
495 source_location orig_parm_replacement_loc)
497 source_location result;
499 linemap_assert (linemap_macro_expansion_map_p (map));
500 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
502 MACRO_MAP_LOCATIONS (map)[2 * token_no] = orig_loc;
503 MACRO_MAP_LOCATIONS (map)[2 * token_no + 1] = orig_parm_replacement_loc;
505 result = MAP_START_LOCATION (map) + token_no;
506 return result;
509 /* Return a source_location for the start (i.e. column==0) of
510 (physical) line TO_LINE in the current source file (as in the
511 most recent linemap_add). MAX_COLUMN_HINT is the highest column
512 number we expect to use in this line (but it does not change
513 the highest_location). */
515 source_location
516 linemap_line_start (struct line_maps *set, linenum_type to_line,
517 unsigned int max_column_hint)
519 struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
520 source_location highest = set->highest_location;
521 source_location r;
522 linenum_type last_line =
523 SOURCE_LINE (map, set->highest_line);
524 int line_delta = to_line - last_line;
525 bool add_map = false;
527 if (line_delta < 0
528 || (line_delta > 10
529 && line_delta * ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) > 1000)
530 || (max_column_hint >= (1U << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map)))
531 || (max_column_hint <= 80
532 && ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) >= 10))
534 add_map = true;
536 else
537 max_column_hint = set->max_column_hint;
538 if (add_map)
540 int column_bits;
541 if (max_column_hint > 100000 || highest > 0x60000000)
543 /* If the column number is ridiculous or we've allocated a huge
544 number of source_locations, give up on column numbers. */
545 max_column_hint = 0;
546 if (highest >0x70000000)
547 return 0;
548 column_bits = 0;
550 else
552 column_bits = 7;
553 while (max_column_hint >= (1U << column_bits))
554 column_bits++;
555 max_column_hint = 1U << column_bits;
557 /* Allocate the new line_map. However, if the current map only has a
558 single line we can sometimes just increase its column_bits instead. */
559 if (line_delta < 0
560 || last_line != ORDINARY_MAP_STARTING_LINE_NUMBER (map)
561 || SOURCE_COLUMN (map, highest) >= (1U << column_bits))
562 map = (struct line_map *) linemap_add (set, LC_RENAME,
563 ORDINARY_MAP_IN_SYSTEM_HEADER_P
564 (map),
565 ORDINARY_MAP_FILE_NAME (map),
566 to_line);
567 ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) = column_bits;
568 r = (MAP_START_LOCATION (map)
569 + ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
570 << column_bits));
572 else
573 r = highest - SOURCE_COLUMN (map, highest)
574 + (line_delta << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map));
576 /* Locations of ordinary tokens are always lower than locations of
577 macro tokens. */
578 if (r >= LINEMAPS_MACRO_LOWEST_LOCATION (set))
579 return 0;
581 set->highest_line = r;
582 if (r > set->highest_location)
583 set->highest_location = r;
584 set->max_column_hint = max_column_hint;
585 return r;
588 /* Encode and return a source_location from a column number. The
589 source line considered is the last source line used to call
590 linemap_line_start, i.e, the last source line which a location was
591 encoded from. */
593 source_location
594 linemap_position_for_column (struct line_maps *set, unsigned int to_column)
596 source_location r = set->highest_line;
598 linemap_assert
599 (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
601 if (to_column >= set->max_column_hint)
603 if (r >= 0xC000000 || to_column > 100000)
605 /* Running low on source_locations - disable column numbers. */
606 return r;
608 else
610 struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
611 r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
614 r = r + to_column;
615 if (r >= set->highest_location)
616 set->highest_location = r;
617 return r;
620 /* Encode and return a source location from a given line and
621 column. */
623 source_location
624 linemap_position_for_line_and_column (struct line_map *map,
625 linenum_type line,
626 unsigned column)
628 linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (map) <= line);
630 return (MAP_START_LOCATION (map)
631 + ((line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
632 << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map))
633 + (column & ((1 << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map)) - 1)));
636 /* Given a virtual source location yielded by a map (either an
637 ordinary or a macro map), returns that map. */
639 const struct line_map*
640 linemap_lookup (struct line_maps *set, source_location line)
642 if (IS_ADHOC_LOC (line))
643 line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
644 if (linemap_location_from_macro_expansion_p (set, line))
645 return linemap_macro_map_lookup (set, line);
646 return linemap_ordinary_map_lookup (set, line);
649 /* Given a source location yielded by an ordinary map, returns that
650 map. Since the set is built chronologically, the logical lines are
651 monotonic increasing, and so the list is sorted and we can use a
652 binary search. */
654 static const struct line_map *
655 linemap_ordinary_map_lookup (struct line_maps *set, source_location line)
657 unsigned int md, mn, mx;
658 const struct line_map *cached, *result;
660 if (IS_ADHOC_LOC (line))
661 line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
663 if (set == NULL || line < RESERVED_LOCATION_COUNT)
664 return NULL;
666 mn = LINEMAPS_ORDINARY_CACHE (set);
667 mx = LINEMAPS_ORDINARY_USED (set);
669 cached = LINEMAPS_ORDINARY_MAP_AT (set, mn);
670 /* We should get a segfault if no line_maps have been added yet. */
671 if (line >= MAP_START_LOCATION (cached))
673 if (mn + 1 == mx || line < MAP_START_LOCATION (&cached[1]))
674 return cached;
676 else
678 mx = mn;
679 mn = 0;
682 while (mx - mn > 1)
684 md = (mn + mx) / 2;
685 if (MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (set, md)) > line)
686 mx = md;
687 else
688 mn = md;
691 LINEMAPS_ORDINARY_CACHE (set) = mn;
692 result = LINEMAPS_ORDINARY_MAP_AT (set, mn);
693 linemap_assert (line >= MAP_START_LOCATION (result));
694 return result;
697 /* Given a source location yielded by a macro map, returns that map.
698 Since the set is built chronologically, the logical lines are
699 monotonic decreasing, and so the list is sorted and we can use a
700 binary search. */
702 static const struct line_map*
703 linemap_macro_map_lookup (struct line_maps *set, source_location line)
705 unsigned int md, mn, mx;
706 const struct line_map *cached, *result;
708 if (IS_ADHOC_LOC (line))
709 line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
711 linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set));
713 if (set == NULL)
714 return NULL;
716 mn = LINEMAPS_MACRO_CACHE (set);
717 mx = LINEMAPS_MACRO_USED (set);
718 cached = LINEMAPS_MACRO_MAP_AT (set, mn);
720 if (line >= MAP_START_LOCATION (cached))
722 if (mn == 0 || line < MAP_START_LOCATION (&cached[-1]))
723 return cached;
724 mx = mn - 1;
725 mn = 0;
728 while (mn < mx)
730 md = (mx + mn) / 2;
731 if (MAP_START_LOCATION (LINEMAPS_MACRO_MAP_AT (set, md)) > line)
732 mn = md + 1;
733 else
734 mx = md;
737 LINEMAPS_MACRO_CACHE (set) = mx;
738 result = LINEMAPS_MACRO_MAP_AT (set, LINEMAPS_MACRO_CACHE (set));
739 linemap_assert (MAP_START_LOCATION (result) <= line);
741 return result;
744 /* Return TRUE if MAP encodes locations coming from a macro
745 replacement-list at macro expansion point. */
747 bool
748 linemap_macro_expansion_map_p (const struct line_map *map)
750 if (!map)
751 return false;
752 return (map->reason == LC_ENTER_MACRO);
755 /* If LOCATION is the locus of a token in a replacement-list of a
756 macro expansion return the location of the macro expansion point.
758 Read the comments of struct line_map and struct line_map_macro in
759 line-map.h to understand what a macro expansion point is. */
761 static source_location
762 linemap_macro_map_loc_to_exp_point (const struct line_map *map,
763 source_location location ATTRIBUTE_UNUSED)
765 linemap_assert (linemap_macro_expansion_map_p (map)
766 && location >= MAP_START_LOCATION (map));
768 /* Make sure LOCATION is correct. */
769 linemap_assert ((location - MAP_START_LOCATION (map))
770 < MACRO_MAP_NUM_MACRO_TOKENS (map));
772 return MACRO_MAP_EXPANSION_POINT_LOCATION (map);
775 /* If LOCATION is the source location of a token that belongs to a
776 macro replacement-list -- as part of a macro expansion -- then
777 return the location of the token at the definition point of the
778 macro. Otherwise, return LOCATION. SET is the set of maps
779 location come from. ORIGINAL_MAP is an output parm. If non NULL,
780 the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
781 returned location comes from. */
783 source_location
784 linemap_macro_map_loc_to_def_point (const struct line_map *map,
785 source_location location)
787 unsigned token_no;
789 linemap_assert (linemap_macro_expansion_map_p (map)
790 && location >= MAP_START_LOCATION (map));
791 linemap_assert (location >= RESERVED_LOCATION_COUNT);
793 token_no = location - MAP_START_LOCATION (map);
794 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
796 location = MACRO_MAP_LOCATIONS (map)[2 * token_no + 1];
798 return location;
801 /* If LOCATION is the locus of a token that is an argument of a
802 function-like macro M and appears in the expansion of M, return the
803 locus of that argument in the context of the caller of M.
805 In other words, this returns the xI location presented in the
806 comments of line_map_macro above. */
807 source_location
808 linemap_macro_map_loc_unwind_toward_spelling (const struct line_map* map,
809 source_location location)
811 unsigned token_no;
813 linemap_assert (linemap_macro_expansion_map_p (map)
814 && location >= MAP_START_LOCATION (map));
815 linemap_assert (location >= RESERVED_LOCATION_COUNT);
817 token_no = location - MAP_START_LOCATION (map);
818 linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
820 location = MACRO_MAP_LOCATIONS (map)[2 * token_no];
822 return location;
825 /* Return the source line number corresponding to source location
826 LOCATION. SET is the line map set LOCATION comes from. If
827 LOCATION is the source location of token that is part of the
828 replacement-list of a macro expansion return the line number of the
829 macro expansion point. */
832 linemap_get_expansion_line (struct line_maps *set,
833 source_location location)
835 const struct line_map *map = NULL;
837 if (IS_ADHOC_LOC (location))
838 location = set->location_adhoc_data_map.data[location
839 & MAX_SOURCE_LOCATION].locus;
841 if (location < RESERVED_LOCATION_COUNT)
842 return 0;
844 location =
845 linemap_macro_loc_to_exp_point (set, location, &map);
847 return SOURCE_LINE (map, location);
850 /* Return the path of the file corresponding to source code location
851 LOCATION.
853 If LOCATION is the source location of token that is part of the
854 replacement-list of a macro expansion return the file path of the
855 macro expansion point.
857 SET is the line map set LOCATION comes from. */
859 const char*
860 linemap_get_expansion_filename (struct line_maps *set,
861 source_location location)
863 const struct line_map *map = NULL;
865 if (IS_ADHOC_LOC (location))
866 location = set->location_adhoc_data_map.data[location
867 & MAX_SOURCE_LOCATION].locus;
869 if (location < RESERVED_LOCATION_COUNT)
870 return NULL;
872 location =
873 linemap_macro_loc_to_exp_point (set, location, &map);
875 return LINEMAP_FILE (map);
878 /* Return the name of the macro associated to MACRO_MAP. */
880 const char*
881 linemap_map_get_macro_name (const struct line_map* macro_map)
883 linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map));
884 return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map));
887 /* Return a positive value if LOCATION is the locus of a token that is
888 located in a system header, O otherwise. It returns 1 if LOCATION
889 is the locus of a token that is located in a system header, and 2
890 if LOCATION is the locus of a token located in a C system header
891 that therefore needs to be extern "C" protected in C++.
893 Note that this function returns 1 if LOCATION belongs to a token
894 that is part of a macro replacement-list defined in a system
895 header, but expanded in a non-system file. */
898 linemap_location_in_system_header_p (struct line_maps *set,
899 source_location location)
901 const struct line_map *map = NULL;
903 if (IS_ADHOC_LOC (location))
904 location = set->location_adhoc_data_map.data[location
905 & MAX_SOURCE_LOCATION].locus;
907 if (location < RESERVED_LOCATION_COUNT)
908 return false;
910 /* Let's look at where the token for LOCATION comes from. */
911 while (true)
913 map = linemap_lookup (set, location);
914 if (map != NULL)
916 if (!linemap_macro_expansion_map_p (map))
917 /* It's a normal token. */
918 return LINEMAP_SYSP (map);
919 else
921 /* It's a token resulting from a macro expansion. */
922 source_location loc =
923 linemap_macro_map_loc_unwind_toward_spelling (map, location);
924 if (loc < RESERVED_LOCATION_COUNT)
925 /* This token might come from a built-in macro. Let's
926 look at where that macro got expanded. */
927 location = linemap_macro_map_loc_to_exp_point (map, location);
928 else
929 location = loc;
932 else
933 break;
935 return false;
938 /* Return TRUE if LOCATION is a source code location of a token coming
939 from a macro replacement-list at a macro expansion point, FALSE
940 otherwise. */
942 bool
943 linemap_location_from_macro_expansion_p (struct line_maps *set,
944 source_location location)
946 if (IS_ADHOC_LOC (location))
947 location = set->location_adhoc_data_map.data[location
948 & MAX_SOURCE_LOCATION].locus;
950 linemap_assert (location <= MAX_SOURCE_LOCATION
951 && (set->highest_location
952 < LINEMAPS_MACRO_LOWEST_LOCATION (set)));
953 if (set == NULL)
954 return false;
955 return (location > set->highest_location);
958 /* Given two virtual locations *LOC0 and *LOC1, return the first
959 common macro map in their macro expansion histories. Return NULL
960 if no common macro was found. *LOC0 (resp. *LOC1) is set to the
961 virtual location of the token inside the resulting macro. */
963 static const struct line_map*
964 first_map_in_common_1 (struct line_maps *set,
965 source_location *loc0,
966 source_location *loc1)
968 source_location l0 = *loc0, l1 = *loc1;
969 const struct line_map *map0 = linemap_lookup (set, l0),
970 *map1 = linemap_lookup (set, l1);
972 while (linemap_macro_expansion_map_p (map0)
973 && linemap_macro_expansion_map_p (map1)
974 && (map0 != map1))
976 if (MAP_START_LOCATION (map0) < MAP_START_LOCATION (map1))
978 l0 = linemap_macro_map_loc_to_exp_point (map0, l0);
979 map0 = linemap_lookup (set, l0);
981 else
983 l1 = linemap_macro_map_loc_to_exp_point (map1, l1);
984 map1 = linemap_lookup (set, l1);
988 if (map0 == map1)
990 *loc0 = l0;
991 *loc1 = l1;
992 return map0;
994 return NULL;
997 /* Given two virtual locations LOC0 and LOC1, return the first common
998 macro map in their macro expansion histories. Return NULL if no
999 common macro was found. *RES_LOC0 (resp. *RES_LOC1) is set to the
1000 virtual location of the token inside the resulting macro, upon
1001 return of a non-NULL result. */
1003 static const struct line_map*
1004 first_map_in_common (struct line_maps *set,
1005 source_location loc0,
1006 source_location loc1,
1007 source_location *res_loc0,
1008 source_location *res_loc1)
1010 *res_loc0 = loc0;
1011 *res_loc1 = loc1;
1013 return first_map_in_common_1 (set, res_loc0, res_loc1);
1016 /* Return a positive value if PRE denotes the location of a token that
1017 comes before the token of POST, 0 if PRE denotes the location of
1018 the same token as the token for POST, and a negative value
1019 otherwise. */
1022 linemap_compare_locations (struct line_maps *set,
1023 source_location pre,
1024 source_location post)
1026 bool pre_virtual_p, post_virtual_p;
1027 source_location l0 = pre, l1 = post;
1029 if (IS_ADHOC_LOC (l0))
1030 l0 = set->location_adhoc_data_map.data[l0 & MAX_SOURCE_LOCATION].locus;
1031 if (IS_ADHOC_LOC (l1))
1032 l1 = set->location_adhoc_data_map.data[l1 & MAX_SOURCE_LOCATION].locus;
1034 if (l0 == l1)
1035 return 0;
1037 if ((pre_virtual_p = linemap_location_from_macro_expansion_p (set, l0)))
1038 l0 = linemap_resolve_location (set, l0,
1039 LRK_MACRO_EXPANSION_POINT,
1040 NULL);
1042 if ((post_virtual_p = linemap_location_from_macro_expansion_p (set, l1)))
1043 l1 = linemap_resolve_location (set, l1,
1044 LRK_MACRO_EXPANSION_POINT,
1045 NULL);
1047 if (l0 == l1
1048 && pre_virtual_p
1049 && post_virtual_p)
1051 /* So pre and post represent two tokens that are present in a
1052 same macro expansion. Let's see if the token for pre was
1053 before the token for post in that expansion. */
1054 unsigned i0, i1;
1055 const struct line_map *map =
1056 first_map_in_common (set, pre, post, &l0, &l1);
1058 if (map == NULL)
1059 /* This should not be possible. */
1060 abort ();
1062 i0 = l0 - MAP_START_LOCATION (map);
1063 i1 = l1 - MAP_START_LOCATION (map);
1064 return i1 - i0;
1067 return l1 - l0;
1070 /* Print an include trace, for e.g. the -H option of the preprocessor. */
1072 static void
1073 trace_include (const struct line_maps *set, const struct line_map *map)
1075 unsigned int i = set->depth;
1077 while (--i)
1078 putc ('.', stderr);
1080 fprintf (stderr, " %s\n", ORDINARY_MAP_FILE_NAME (map));
1083 /* Return the spelling location of the token wherever it comes from,
1084 whether part of a macro definition or not.
1086 This is a subroutine for linemap_resolve_location. */
1088 static source_location
1089 linemap_macro_loc_to_spelling_point (struct line_maps *set,
1090 source_location location,
1091 const struct line_map **original_map)
1093 struct line_map *map;
1095 if (IS_ADHOC_LOC (location))
1096 location = set->location_adhoc_data_map.data[location
1097 & MAX_SOURCE_LOCATION].locus;
1099 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1101 while (true)
1103 map = (struct line_map*) linemap_lookup (set, location);
1104 if (!linemap_macro_expansion_map_p (map))
1105 break;
1107 location =
1108 linemap_macro_map_loc_unwind_toward_spelling (map, location);
1111 if (original_map)
1112 *original_map = map;
1113 return location;
1116 /* If LOCATION is the source location of a token that belongs to a
1117 macro replacement-list -- as part of a macro expansion -- then
1118 return the location of the token at the definition point of the
1119 macro. Otherwise, return LOCATION. SET is the set of maps
1120 location come from. ORIGINAL_MAP is an output parm. If non NULL,
1121 the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
1122 returned location comes from.
1124 This is a subroutine of linemap_resolve_location. */
1126 static source_location
1127 linemap_macro_loc_to_def_point (struct line_maps *set,
1128 source_location location,
1129 const struct line_map **original_map)
1131 struct line_map *map;
1133 if (IS_ADHOC_LOC (location))
1134 location = set->location_adhoc_data_map.data[location
1135 & MAX_SOURCE_LOCATION].locus;
1137 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1139 while (true)
1141 map = (struct line_map*) linemap_lookup (set, location);
1142 if (!linemap_macro_expansion_map_p (map))
1143 break;
1145 location =
1146 linemap_macro_map_loc_to_def_point (map, location);
1149 if (original_map)
1150 *original_map = map;
1151 return location;
1154 /* If LOCATION is the source location of a token that belongs to a
1155 macro replacement-list -- at a macro expansion point -- then return
1156 the location of the topmost expansion point of the macro. We say
1157 topmost because if we are in the context of a nested macro
1158 expansion, the function returns the source location of the first
1159 macro expansion that triggered the nested expansions.
1161 Otherwise, return LOCATION. SET is the set of maps location come
1162 from. ORIGINAL_MAP is an output parm. If non NULL, the function
1163 sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
1164 location comes from.
1166 This is a subroutine of linemap_resolve_location. */
1168 static source_location
1169 linemap_macro_loc_to_exp_point (struct line_maps *set,
1170 source_location location,
1171 const struct line_map **original_map)
1173 struct line_map *map;
1175 if (IS_ADHOC_LOC (location))
1176 location = set->location_adhoc_data_map.data[location
1177 & MAX_SOURCE_LOCATION].locus;
1179 linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1181 while (true)
1183 map = (struct line_map*) linemap_lookup (set, location);
1184 if (!linemap_macro_expansion_map_p (map))
1185 break;
1186 location = linemap_macro_map_loc_to_exp_point (map, location);
1189 if (original_map)
1190 *original_map = map;
1191 return location;
1194 /* Resolve a virtual location into either a spelling location, an
1195 expansion point location or a token argument replacement point
1196 location. Return the map that encodes the virtual location as well
1197 as the resolved location.
1199 If LOC is *NOT* the location of a token resulting from the
1200 expansion of a macro, then the parameter LRK (which stands for
1201 Location Resolution Kind) is ignored and the resulting location
1202 just equals the one given in argument.
1204 Now if LOC *IS* the location of a token resulting from the
1205 expansion of a macro, this is what happens.
1207 * If LRK is set to LRK_MACRO_EXPANSION_POINT
1208 -------------------------------
1210 The virtual location is resolved to the first macro expansion point
1211 that led to this macro expansion.
1213 * If LRK is set to LRK_SPELLING_LOCATION
1214 -------------------------------------
1216 The virtual location is resolved to the locus where the token has
1217 been spelled in the source. This can follow through all the macro
1218 expansions that led to the token.
1220 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1221 --------------------------------------
1223 The virtual location is resolved to the locus of the token in the
1224 context of the macro definition.
1226 If LOC is the locus of a token that is an argument of a
1227 function-like macro [replacing a parameter in the replacement list
1228 of the macro] the virtual location is resolved to the locus of the
1229 parameter that is replaced, in the context of the definition of the
1230 macro.
1232 If LOC is the locus of a token that is not an argument of a
1233 function-like macro, then the function behaves as if LRK was set to
1234 LRK_SPELLING_LOCATION.
1236 If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the
1237 returned location. Note that if the returned location wasn't originally
1238 encoded by a map, the *MAP is set to NULL. This can happen if LOC
1239 resolves to a location reserved for the client code, like
1240 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
1242 source_location
1243 linemap_resolve_location (struct line_maps *set,
1244 source_location loc,
1245 enum location_resolution_kind lrk,
1246 const struct line_map **map)
1248 if (IS_ADHOC_LOC (loc))
1249 loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1251 if (loc < RESERVED_LOCATION_COUNT)
1253 /* A reserved location wasn't encoded in a map. Let's return a
1254 NULL map here, just like what linemap_ordinary_map_lookup
1255 does. */
1256 if (map)
1257 *map = NULL;
1258 return loc;
1261 switch (lrk)
1263 case LRK_MACRO_EXPANSION_POINT:
1264 loc = linemap_macro_loc_to_exp_point (set, loc, map);
1265 break;
1266 case LRK_SPELLING_LOCATION:
1267 loc = linemap_macro_loc_to_spelling_point (set, loc, map);
1268 break;
1269 case LRK_MACRO_DEFINITION_LOCATION:
1270 loc = linemap_macro_loc_to_def_point (set, loc, map);
1271 break;
1272 default:
1273 abort ();
1275 return loc;
1279 Suppose that LOC is the virtual location of a token T coming from
1280 the expansion of a macro M. This function then steps up to get the
1281 location L of the point where M got expanded. If L is a spelling
1282 location inside a macro expansion M', then this function returns
1283 the locus of the point where M' was expanded. Said otherwise, this
1284 function returns the location of T in the context that triggered
1285 the expansion of M.
1287 *LOC_MAP must be set to the map of LOC. This function then sets it
1288 to the map of the returned location. */
1290 source_location
1291 linemap_unwind_toward_expansion (struct line_maps *set,
1292 source_location loc,
1293 const struct line_map **map)
1295 source_location resolved_location;
1296 const struct line_map *resolved_map;
1298 if (IS_ADHOC_LOC (loc))
1299 loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1301 resolved_location =
1302 linemap_macro_map_loc_unwind_toward_spelling (*map, loc);
1303 resolved_map = linemap_lookup (set, resolved_location);
1305 if (!linemap_macro_expansion_map_p (resolved_map))
1307 resolved_location = linemap_macro_map_loc_to_exp_point (*map, loc);
1308 resolved_map = linemap_lookup (set, resolved_location);
1311 *map = resolved_map;
1312 return resolved_location;
1315 /* If LOC is the virtual location of a token coming from the expansion
1316 of a macro M and if its spelling location is reserved (e.g, a
1317 location for a built-in token), then this function unwinds (using
1318 linemap_unwind_toward_expansion) the location until a location that
1319 is not reserved and is not in a system header is reached. In other
1320 words, this unwinds the reserved location until a location that is
1321 in real source code is reached.
1323 Otherwise, if the spelling location for LOC is not reserved or if
1324 LOC doesn't come from the expansion of a macro, the function
1325 returns LOC as is and *MAP is not touched.
1327 *MAP is set to the map of the returned location if the later is
1328 different from LOC. */
1329 source_location
1330 linemap_unwind_to_first_non_reserved_loc (struct line_maps *set,
1331 source_location loc,
1332 const struct line_map **map)
1334 source_location resolved_loc;
1335 const struct line_map *map0 = NULL, *map1 = NULL;
1337 if (IS_ADHOC_LOC (loc))
1338 loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1340 map0 = linemap_lookup (set, loc);
1341 if (!linemap_macro_expansion_map_p (map0))
1342 return loc;
1344 resolved_loc = linemap_resolve_location (set, loc,
1345 LRK_SPELLING_LOCATION,
1346 &map1);
1348 if (resolved_loc >= RESERVED_LOCATION_COUNT
1349 && !LINEMAP_SYSP (map1))
1350 return loc;
1352 while (linemap_macro_expansion_map_p (map0)
1353 && (resolved_loc < RESERVED_LOCATION_COUNT
1354 || LINEMAP_SYSP (map1)))
1356 loc = linemap_unwind_toward_expansion (set, loc, &map0);
1357 resolved_loc = linemap_resolve_location (set, loc,
1358 LRK_SPELLING_LOCATION,
1359 &map1);
1362 if (map != NULL)
1363 *map = map0;
1364 return loc;
1367 /* Expand source code location LOC and return a user readable source
1368 code location. LOC must be a spelling (non-virtual) location. If
1369 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1370 location is returned. */
1372 expanded_location
1373 linemap_expand_location (struct line_maps *set,
1374 const struct line_map *map,
1375 source_location loc)
1378 expanded_location xloc;
1380 memset (&xloc, 0, sizeof (xloc));
1381 if (IS_ADHOC_LOC (loc))
1383 loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1384 xloc.data
1385 = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
1388 if (loc < RESERVED_LOCATION_COUNT)
1389 /* The location for this token wasn't generated from a line map.
1390 It was probably a location for a builtin token, chosen by some
1391 client code. Let's not try to expand the location in that
1392 case. */;
1393 else if (map == NULL)
1394 /* We shouldn't be getting a NULL map with a location that is not
1395 reserved by the client code. */
1396 abort ();
1397 else
1399 /* MAP must be an ordinary map and LOC must be non-virtual,
1400 encoded into this map, obviously; the accessors used on MAP
1401 below ensure it is ordinary. Let's just assert the
1402 non-virtualness of LOC here. */
1403 if (linemap_location_from_macro_expansion_p (set, loc))
1404 abort ();
1406 xloc.file = LINEMAP_FILE (map);
1407 xloc.line = SOURCE_LINE (map, loc);
1408 xloc.column = SOURCE_COLUMN (map, loc);
1409 xloc.sysp = LINEMAP_SYSP (map) != 0;
1412 return xloc;
1416 /* Dump line map at index IX in line table SET to STREAM. If STREAM
1417 is NULL, use stderr. IS_MACRO is true if the caller wants to
1418 dump a macro map, false otherwise. */
1420 void
1421 linemap_dump (FILE *stream, struct line_maps *set, unsigned ix, bool is_macro)
1423 const char *lc_reasons_v[LC_ENTER_MACRO + 1]
1424 = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
1425 "LC_ENTER_MACRO" };
1426 const char *reason;
1427 struct line_map *map;
1429 if (stream == NULL)
1430 stream = stderr;
1432 if (!is_macro)
1433 map = LINEMAPS_ORDINARY_MAP_AT (set, ix);
1434 else
1435 map = LINEMAPS_MACRO_MAP_AT (set, ix);
1437 reason = (map->reason <= LC_ENTER_MACRO) ? lc_reasons_v[map->reason] : "???";
1439 fprintf (stream, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
1440 ix, (void *) map, map->start_location, reason,
1441 (!is_macro && ORDINARY_MAP_IN_SYSTEM_HEADER_P (map)) ? "yes" : "no");
1442 if (!is_macro)
1444 unsigned includer_ix;
1445 struct line_map *includer_map;
1447 includer_ix = ORDINARY_MAP_INCLUDER_FILE_INDEX (map);
1448 includer_map = includer_ix < LINEMAPS_ORDINARY_USED (set)
1449 ? LINEMAPS_ORDINARY_MAP_AT (set, includer_ix)
1450 : NULL;
1452 fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (map),
1453 ORDINARY_MAP_STARTING_LINE_NUMBER (map));
1454 fprintf (stream, "Included from: [%d] %s\n", includer_ix,
1455 includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None");
1457 else
1458 fprintf (stream, "Macro: %s (%u tokens)\n",
1459 linemap_map_get_macro_name (map),
1460 MACRO_MAP_NUM_MACRO_TOKENS (map));
1462 fprintf (stream, "\n");
1466 /* Dump debugging information about source location LOC into the file
1467 stream STREAM. SET is the line map set LOC comes from. */
1469 void
1470 linemap_dump_location (struct line_maps *set,
1471 source_location loc,
1472 FILE *stream)
1474 const struct line_map *map;
1475 source_location location;
1476 const char *path = "", *from = "";
1477 int l = -1, c = -1, s = -1, e = -1;
1479 if (IS_ADHOC_LOC (loc))
1480 loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1482 if (loc == 0)
1483 return;
1485 location =
1486 linemap_resolve_location (set, loc, LRK_MACRO_DEFINITION_LOCATION, &map);
1488 if (map == NULL)
1489 /* Only reserved locations can be tolerated in this case. */
1490 linemap_assert (location < RESERVED_LOCATION_COUNT);
1491 else
1493 path = LINEMAP_FILE (map);
1494 l = SOURCE_LINE (map, location);
1495 c = SOURCE_COLUMN (map, location);
1496 s = LINEMAP_SYSP (map) != 0;
1497 e = location != loc;
1498 if (e)
1499 from = "N/A";
1500 else
1501 from = (INCLUDED_FROM (set, map))
1502 ? LINEMAP_FILE (INCLUDED_FROM (set, map))
1503 : "<NULL>";
1506 /* P: path, L: line, C: column, S: in-system-header, M: map address,
1507 E: macro expansion?, LOC: original location, R: resolved location */
1508 fprintf (stream, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}",
1509 path, from, l, c, s, (void*)map, e, loc, location);
1512 /* Return the highest location emitted for a given file for which
1513 there is a line map in SET. FILE_NAME is the file name to
1514 consider. If the function returns TRUE, *LOC is set to the highest
1515 location emitted for that file. */
1517 bool
1518 linemap_get_file_highest_location (struct line_maps *set,
1519 const char *file_name,
1520 source_location *loc)
1522 /* If the set is empty or no ordinary map has been created then
1523 there is no file to look for ... */
1524 if (set == NULL || set->info_ordinary.used == 0)
1525 return false;
1527 /* Now look for the last ordinary map created for FILE_NAME. */
1528 int i;
1529 for (i = set->info_ordinary.used - 1; i >= 0; --i)
1531 const char *fname = set->info_ordinary.maps[i].d.ordinary.to_file;
1532 if (fname && !filename_cmp (fname, file_name))
1533 break;
1536 if (i < 0)
1537 return false;
1539 /* The highest location for a given map is either the starting
1540 location of the next map minus one, or -- if the map is the
1541 latest one -- the highest location of the set. */
1542 source_location result;
1543 if (i == (int) set->info_ordinary.used - 1)
1544 result = set->highest_location;
1545 else
1546 result = set->info_ordinary.maps[i + 1].start_location - 1;
1548 *loc = result;
1549 return true;
1552 /* Compute and return statistics about the memory consumption of some
1553 parts of the line table SET. */
1555 void
1556 linemap_get_statistics (struct line_maps *set,
1557 struct linemap_stats *s)
1559 long ordinary_maps_allocated_size, ordinary_maps_used_size,
1560 macro_maps_allocated_size, macro_maps_used_size,
1561 macro_maps_locations_size = 0, duplicated_macro_maps_locations_size = 0;
1563 struct line_map *cur_map;
1565 ordinary_maps_allocated_size =
1566 LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map);
1568 ordinary_maps_used_size =
1569 LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map);
1571 macro_maps_allocated_size =
1572 LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map);
1574 for (cur_map = LINEMAPS_MACRO_MAPS (set);
1575 cur_map && cur_map <= LINEMAPS_LAST_MACRO_MAP (set);
1576 ++cur_map)
1578 unsigned i;
1580 linemap_assert (linemap_macro_expansion_map_p (cur_map));
1582 macro_maps_locations_size +=
1583 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map) * sizeof (source_location);
1585 for (i = 0; i < 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map); i += 2)
1587 if (MACRO_MAP_LOCATIONS (cur_map)[i] ==
1588 MACRO_MAP_LOCATIONS (cur_map)[i + 1])
1589 duplicated_macro_maps_locations_size +=
1590 sizeof (source_location);
1594 macro_maps_used_size =
1595 LINEMAPS_MACRO_USED (set) * sizeof (struct line_map);
1597 s->num_ordinary_maps_allocated = LINEMAPS_ORDINARY_ALLOCATED (set);
1598 s->num_ordinary_maps_used = LINEMAPS_ORDINARY_USED (set);
1599 s->ordinary_maps_allocated_size = ordinary_maps_allocated_size;
1600 s->ordinary_maps_used_size = ordinary_maps_used_size;
1601 s->num_expanded_macros = num_expanded_macros_counter;
1602 s->num_macro_tokens = num_macro_tokens_counter;
1603 s->num_macro_maps_used = LINEMAPS_MACRO_USED (set);
1604 s->macro_maps_allocated_size = macro_maps_allocated_size;
1605 s->macro_maps_locations_size = macro_maps_locations_size;
1606 s->macro_maps_used_size = macro_maps_used_size;
1607 s->duplicated_macro_maps_locations_size =
1608 duplicated_macro_maps_locations_size;
1612 /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
1613 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
1614 specifies how many macro maps to dump. */
1616 void
1617 line_table_dump (FILE *stream, struct line_maps *set, unsigned int num_ordinary,
1618 unsigned int num_macro)
1620 unsigned int i;
1622 if (set == NULL)
1623 return;
1625 if (stream == NULL)
1626 stream = stderr;
1628 fprintf (stream, "# of ordinary maps: %d\n", LINEMAPS_ORDINARY_USED (set));
1629 fprintf (stream, "# of macro maps: %d\n", LINEMAPS_MACRO_USED (set));
1630 fprintf (stream, "Include stack depth: %d\n", set->depth);
1631 fprintf (stream, "Highest location: %u\n", set->highest_location);
1633 if (num_ordinary)
1635 fprintf (stream, "\nOrdinary line maps\n");
1636 for (i = 0; i < num_ordinary && i < LINEMAPS_ORDINARY_USED (set); i++)
1637 linemap_dump (stream, set, i, false);
1638 fprintf (stream, "\n");
1641 if (num_macro)
1643 fprintf (stream, "\nMacro line maps\n");
1644 for (i = 0; i < num_macro && i < LINEMAPS_MACRO_USED (set); i++)
1645 linemap_dump (stream, set, i, true);
1646 fprintf (stream, "\n");