1 /* Data and functions related to line maps and input files.
2 Copyright (C) 2004-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "diagnostic-core.h"
28 /* This is a cache used by get_next_line to store the content of a
29 file to be searched for file lines. */
32 /* These are information used to store a line boundary. */
35 /* The line number. It starts from 1. */
38 /* The position (byte count) of the beginning of the line,
39 relative to the file data pointer. This starts at zero. */
42 /* The position (byte count) of the last byte of the line. This
43 normally points to the '\n' character, or to one byte after the
44 last byte of the file, if the file doesn't contain a '\n'
48 line_info (size_t l
, size_t s
, size_t e
)
49 : line_num (l
), start_pos (s
), end_pos (e
)
53 :line_num (0), start_pos (0), end_pos (0)
57 /* The number of time this file has been accessed. This is used
58 to designate which file cache to evict from the cache
62 const char *file_path
;
66 /* This points to the content of the file that we've read so
70 /* The size of the DATA array above.*/
73 /* The number of bytes read from the underlying file so far. This
74 must be less (or equal) than SIZE above. */
77 /* The index of the beginning of the current line. */
78 size_t line_start_idx
;
80 /* The number of the previous line read. This starts at 1. Zero
81 means we've read no line so far. */
84 /* This is the total number of lines of the current file. At the
85 moment, we try to get this information from the line map
86 subsystem. Note that this is just a hint. When using the C++
87 front-end, this hint is correct because the input file is then
88 completely tokenized before parsing starts; so the line map knows
89 the number of lines before compilation really starts. For e.g,
90 the C front-end, it can happen that we start emitting diagnostics
91 before the line map has seen the end of the file. */
94 /* This is a record of the beginning and end of the lines we've seen
95 while reading the file. This is useful to avoid walking the data
96 from the beginning when we are asked to read a line that is
97 before LINE_START_IDX above. Note that the maximum size of this
98 record is fcache_line_record_size, so that the memory consumption
99 doesn't explode. We thus scale total_lines down to
100 fcache_line_record_size. */
101 vec
<line_info
, va_heap
> line_record
;
107 /* Current position in real source file. */
109 location_t input_location
= UNKNOWN_LOCATION
;
111 struct line_maps
*line_table
;
113 static fcache
*fcache_tab
;
114 static const size_t fcache_tab_size
= 16;
115 static const size_t fcache_buffer_size
= 4 * 1024;
116 static const size_t fcache_line_record_size
= 100;
118 /* Expand the source location LOC into a human readable location. If
119 LOC resolves to a builtin location, the file name of the readable
120 location is set to the string "<built-in>". If EXPANSION_POINT_P is
121 TRUE and LOC is virtual, then it is resolved to the expansion
122 point of the involved macro. Otherwise, it is resolved to the
123 spelling location of the token.
125 When resolving to the spelling location of the token, if the
126 resulting location is for a built-in location (that is, it has no
127 associated line/column) in the context of a macro expansion, the
128 returned location is the first one (while unwinding the macro
129 location towards its expansion point) that is in real source
132 static expanded_location
133 expand_location_1 (source_location loc
,
134 bool expansion_point_p
)
136 expanded_location xloc
;
137 const line_map_ordinary
*map
;
138 enum location_resolution_kind lrk
= LRK_MACRO_EXPANSION_POINT
;
141 if (IS_ADHOC_LOC (loc
))
143 block
= LOCATION_BLOCK (loc
);
144 loc
= LOCATION_LOCUS (loc
);
147 memset (&xloc
, 0, sizeof (xloc
));
149 if (loc
>= RESERVED_LOCATION_COUNT
)
151 if (!expansion_point_p
)
153 /* We want to resolve LOC to its spelling location.
155 But if that spelling location is a reserved location that
156 appears in the context of a macro expansion (like for a
157 location for a built-in token), let's consider the first
158 location (toward the expansion point) that is not reserved;
159 that is, the first location that is in real source code. */
160 loc
= linemap_unwind_to_first_non_reserved_loc (line_table
,
162 lrk
= LRK_SPELLING_LOCATION
;
164 loc
= linemap_resolve_location (line_table
, loc
,
166 xloc
= linemap_expand_location (line_table
, map
, loc
);
170 if (loc
<= BUILTINS_LOCATION
)
171 xloc
.file
= loc
== UNKNOWN_LOCATION
? NULL
: _("<built-in>");
176 /* Initialize the set of cache used for files accessed by caret
180 diagnostic_file_cache_init (void)
182 if (fcache_tab
== NULL
)
183 fcache_tab
= new fcache
[fcache_tab_size
];
186 /* Free the resources used by the set of cache used for files accessed
187 by caret diagnostic. */
190 diagnostic_file_cache_fini (void)
194 delete [] (fcache_tab
);
199 /* Return the total lines number that have been read so far by the
200 line map (in the preprocessor) so far. For languages like C++ that
201 entirely preprocess the input file before starting to parse, this
202 equals the actual number of lines of the file. */
205 total_lines_num (const char *file_path
)
208 source_location l
= 0;
209 if (linemap_get_file_highest_location (line_table
, file_path
, &l
))
211 gcc_assert (l
>= RESERVED_LOCATION_COUNT
);
212 expanded_location xloc
= expand_location (l
);
218 /* Lookup the cache used for the content of a given file accessed by
219 caret diagnostic. Return the found cached file, or NULL if no
220 cached file was found. */
223 lookup_file_in_cache_tab (const char *file_path
)
225 if (file_path
== NULL
)
228 diagnostic_file_cache_init ();
230 /* This will contain the found cached file. */
232 for (unsigned i
= 0; i
< fcache_tab_size
; ++i
)
234 fcache
*c
= &fcache_tab
[i
];
235 if (c
->file_path
&& !strcmp (c
->file_path
, file_path
))
248 /* Return the file cache that has been less used, recently, or the
249 first empty one. If HIGHEST_USE_COUNT is non-null,
250 *HIGHEST_USE_COUNT is set to the highest use count of the entries
251 in the cache table. */
254 evicted_cache_tab_entry (unsigned *highest_use_count
)
256 diagnostic_file_cache_init ();
258 fcache
*to_evict
= &fcache_tab
[0];
259 unsigned huc
= to_evict
->use_count
;
260 for (unsigned i
= 1; i
< fcache_tab_size
; ++i
)
262 fcache
*c
= &fcache_tab
[i
];
263 bool c_is_empty
= (c
->file_path
== NULL
);
265 if (c
->use_count
< to_evict
->use_count
266 || (to_evict
->file_path
&& c_is_empty
))
267 /* We evict C because it's either an entry with a lower use
268 count or one that is empty. */
271 if (huc
< c
->use_count
)
275 /* We've reached the end of the cache; subsequent elements are
280 if (highest_use_count
)
281 *highest_use_count
= huc
;
286 /* Create the cache used for the content of a given file to be
287 accessed by caret diagnostic. This cache is added to an array of
288 cache and can be retrieved by lookup_file_in_cache_tab. This
289 function returns the created cache. Note that only the last
290 fcache_tab_size files are cached. */
293 add_file_to_cache_tab (const char *file_path
)
296 FILE *fp
= fopen (file_path
, "r");
300 unsigned highest_use_count
= 0;
301 fcache
*r
= evicted_cache_tab_entry (&highest_use_count
);
302 r
->file_path
= file_path
;
307 r
->line_start_idx
= 0;
309 r
->line_record
.truncate (0);
310 /* Ensure that this cache entry doesn't get evicted next time
311 add_file_to_cache_tab is called. */
312 r
->use_count
= ++highest_use_count
;
313 r
->total_lines
= total_lines_num (file_path
);
318 /* Lookup the cache used for the content of a given file accessed by
319 caret diagnostic. If no cached file was found, create a new cache
320 for this file, add it to the array of cached file and return
324 lookup_or_add_file_to_cache_tab (const char *file_path
)
326 fcache
*r
= lookup_file_in_cache_tab (file_path
);
328 r
= add_file_to_cache_tab (file_path
);
332 /* Default constructor for a cache of file used by caret
336 : use_count (0), file_path (NULL
), fp (NULL
), data (0),
337 size (0), nb_read (0), line_start_idx (0), line_num (0),
340 line_record
.create (0);
343 /* Destructor for a cache of file used by caret diagnostic. */
357 line_record
.release ();
360 /* Returns TRUE iff the cache would need to be filled with data coming
361 from the file. That is, either the cache is empty or full or the
362 current line is empty. Note that if the cache is full, it would
363 need to be extended and filled again. */
366 needs_read (fcache
*c
)
368 return (c
->nb_read
== 0
369 || c
->nb_read
== c
->size
370 || (c
->line_start_idx
>= c
->nb_read
- 1));
373 /* Return TRUE iff the cache is full and thus needs to be
377 needs_grow (fcache
*c
)
379 return c
->nb_read
== c
->size
;
382 /* Grow the cache if it needs to be extended. */
385 maybe_grow (fcache
*c
)
390 size_t size
= c
->size
== 0 ? fcache_buffer_size
: c
->size
* 2;
391 c
->data
= XRESIZEVEC (char, c
->data
, size
+ 1);
395 /* Read more data into the cache. Extends the cache if need be.
396 Returns TRUE iff new data could be read. */
399 read_data (fcache
*c
)
401 if (feof (c
->fp
) || ferror (c
->fp
))
406 char * from
= c
->data
+ c
->nb_read
;
407 size_t to_read
= c
->size
- c
->nb_read
;
408 size_t nb_read
= fread (from
, 1, to_read
, c
->fp
);
413 c
->nb_read
+= nb_read
;
417 /* Read new data iff the cache needs to be filled with more data
418 coming from the file FP. Return TRUE iff the cache was filled with
422 maybe_read_data (fcache
*c
)
426 return read_data (c
);
429 /* Read a new line from file FP, using C as a cache for the data
430 coming from the file. Upon successful completion, *LINE is set to
431 the beginning of the line found. Space for that line has been
432 allocated in the cache thus *LINE has the same life time as C.
433 *LINE_LEN is set to the length of the line. Note that the line
434 does not contain any terminal delimiter. This function returns
435 true if some data was read or process from the cache, false
436 otherwise. Note that subsequent calls to get_next_line return the
437 next lines of the file and might overwrite the content of
441 get_next_line (fcache
*c
, char **line
, ssize_t
*line_len
)
443 /* Fill the cache with data to process. */
446 size_t remaining_size
= c
->nb_read
- c
->line_start_idx
;
447 if (remaining_size
== 0)
448 /* There is no more data to process. */
451 char *line_start
= c
->data
+ c
->line_start_idx
;
453 char *next_line_start
= NULL
;
455 char *line_end
= (char *) memchr (line_start
, '\n', remaining_size
);
456 if (line_end
== NULL
)
458 /* We haven't found the end-of-line delimiter in the cache.
459 Fill the cache with more data from the file and look for the
461 while (maybe_read_data (c
))
463 line_start
= c
->data
+ c
->line_start_idx
;
464 remaining_size
= c
->nb_read
- c
->line_start_idx
;
465 line_end
= (char *) memchr (line_start
, '\n', remaining_size
);
466 if (line_end
!= NULL
)
468 next_line_start
= line_end
+ 1;
472 if (line_end
== NULL
)
473 /* We've loadded all the file into the cache and still no
474 '\n'. Let's say the line ends up at one byte passed the
475 end of the file. This is to stay consistent with the case
476 of when the line ends up with a '\n' and line_end points to
477 that terminal '\n'. That consistency is useful below in
478 the len calculation. */
479 line_end
= c
->data
+ c
->nb_read
;
482 next_line_start
= line_end
+ 1;
487 /* At this point, we've found the end of the of line. It either
488 points to the '\n' or to one byte after the last byte of the
490 gcc_assert (line_end
!= NULL
);
492 len
= line_end
- line_start
;
494 if (c
->line_start_idx
< c
->nb_read
)
499 /* Before we update our line record, make sure the hint about the
500 total number of lines of the file is correct. If it's not, then
501 we give up recording line boundaries from now on. */
502 bool update_line_record
= true;
503 if (c
->line_num
> c
->total_lines
)
504 update_line_record
= false;
506 /* Now update our line record so that re-reading lines from the
507 before c->line_start_idx is faster. */
508 if (update_line_record
509 && c
->line_record
.length () < fcache_line_record_size
)
511 /* If the file lines fits in the line record, we just record all
513 if (c
->total_lines
<= fcache_line_record_size
514 && c
->line_num
> c
->line_record
.length ())
515 c
->line_record
.safe_push (fcache::line_info (c
->line_num
,
517 line_end
- c
->data
));
518 else if (c
->total_lines
> fcache_line_record_size
)
520 /* ... otherwise, we just scale total_lines down to
521 (fcache_line_record_size lines. */
522 size_t n
= (c
->line_num
* fcache_line_record_size
) / c
->total_lines
;
523 if (c
->line_record
.length () == 0
524 || n
>= c
->line_record
.length ())
525 c
->line_record
.safe_push (fcache::line_info (c
->line_num
,
527 line_end
- c
->data
));
531 /* Update c->line_start_idx so that it points to the next line to be
534 c
->line_start_idx
= next_line_start
- c
->data
;
536 /* We didn't find any terminal '\n'. Let's consider that the end
537 of line is the end of the data in the cache. The next
538 invocation of get_next_line will either read more data from the
539 underlying file or return false early because we've reached the
541 c
->line_start_idx
= c
->nb_read
;
548 /* Reads the next line from FILE into *LINE. If *LINE is too small
549 (or NULL) it is allocated (or extended) to have enough space to
550 containe the line. *LINE_LENGTH must contain the size of the
551 initial*LINE buffer. It's then updated by this function to the
552 actual length of the returned line. Note that the returned line
553 can contain several zero bytes. Also note that the returned string
554 is allocated in static storage that is going to be re-used by
555 subsequent invocations of read_line. */
558 read_next_line (fcache
*cache
, char ** line
, ssize_t
*line_len
)
563 if (!get_next_line (cache
, &l
, &len
))
567 *line
= XNEWVEC (char, len
);
570 *line
= XRESIZEVEC (char, *line
, len
);
572 memcpy (*line
, l
, len
);
578 /* Consume the next bytes coming from the cache (or from its
579 underlying file if there are remaining unread bytes in the file)
580 until we reach the next end-of-line (or end-of-file). There is no
581 copying from the cache involved. Return TRUE upon successful
585 goto_next_line (fcache
*cache
)
590 return get_next_line (cache
, &l
, &len
);
593 /* Read an arbitrary line number LINE_NUM from the file cached in C.
594 The line is copied into *LINE. *LINE_LEN must have been set to the
595 length of *LINE. If *LINE is too small (or NULL) it's extended (or
596 allocated) and *LINE_LEN is adjusted accordingly. *LINE ends up
597 with a terminal zero byte and can contain additional zero bytes.
598 This function returns bool if a line was read. */
601 read_line_num (fcache
*c
, size_t line_num
,
602 char ** line
, ssize_t
*line_len
)
604 gcc_assert (line_num
> 0);
606 if (line_num
<= c
->line_num
)
608 /* We've been asked to read lines that are before c->line_num.
609 So lets use our line record (if it's not empty) to try to
610 avoid re-reading the file from the beginning again. */
612 if (c
->line_record
.is_empty ())
614 c
->line_start_idx
= 0;
619 fcache::line_info
*i
= NULL
;
620 if (c
->total_lines
<= fcache_line_record_size
)
622 /* In languages where the input file is not totally
623 preprocessed up front, the c->total_lines hint
624 can be smaller than the number of lines of the
625 file. In that case, only the first
626 c->total_lines have been recorded.
628 Otherwise, the first c->total_lines we've read have
629 their start/end recorded here. */
630 i
= (line_num
<= c
->total_lines
)
631 ? &c
->line_record
[line_num
- 1]
632 : &c
->line_record
[c
->total_lines
- 1];
633 gcc_assert (i
->line_num
<= line_num
);
637 /* So the file had more lines than our line record
638 size. Thus the number of lines we've recorded has
639 been scaled down to fcache_line_reacord_size. Let's
640 pick the start/end of the recorded line that is
641 closest to line_num. */
642 size_t n
= (line_num
<= c
->total_lines
)
643 ? line_num
* fcache_line_record_size
/ c
->total_lines
644 : c
->line_record
.length () - 1;
645 if (n
< c
->line_record
.length ())
647 i
= &c
->line_record
[n
];
648 gcc_assert (i
->line_num
<= line_num
);
652 if (i
&& i
->line_num
== line_num
)
654 /* We have the start/end of the line. Let's just copy
655 it again and we are done. */
656 ssize_t len
= i
->end_pos
- i
->start_pos
+ 1;
658 *line
= XRESIZEVEC (char, *line
, len
);
659 memmove (*line
, c
->data
+ i
->start_pos
, len
);
660 (*line
)[len
- 1] = '\0';
667 c
->line_start_idx
= i
->start_pos
;
668 c
->line_num
= i
->line_num
- 1;
672 c
->line_start_idx
= 0;
678 /* Let's walk from line c->line_num up to line_num - 1, without
680 while (c
->line_num
< line_num
- 1)
681 if (!goto_next_line (c
))
684 /* The line we want is the next one. Let's read and copy it back to
686 return read_next_line (c
, line
, line_len
);
689 /* Return the physical source line that corresponds to FILE_PATH/LINE in a
690 buffer that is statically allocated. The newline is replaced by
691 the null character. Note that the line can contain several null
692 characters, so LINE_LEN, if non-null, points to the actual length
696 location_get_source_line (const char *file_path
, int line
,
705 fcache
*c
= lookup_or_add_file_to_cache_tab (file_path
);
709 bool read
= read_line_num (c
, line
, &buffer
, &len
);
711 if (read
&& line_len
)
714 return read
? buffer
: NULL
;
717 /* Test if the location originates from the spelling location of a
718 builtin-tokens. That is, return TRUE if LOC is a (possibly
719 virtual) location of a built-in token that appears in the expansion
720 list of a macro. Please note that this function also works on
721 tokens that result from built-in tokens. For instance, the
722 function would return true if passed a token "4" that is the result
723 of the expansion of the built-in __LINE__ macro. */
725 is_location_from_builtin_token (source_location loc
)
727 const line_map_ordinary
*map
= NULL
;
728 loc
= linemap_resolve_location (line_table
, loc
,
729 LRK_SPELLING_LOCATION
, &map
);
730 return loc
== BUILTINS_LOCATION
;
733 /* Expand the source location LOC into a human readable location. If
734 LOC is virtual, it resolves to the expansion point of the involved
735 macro. If LOC resolves to a builtin location, the file name of the
736 readable location is set to the string "<built-in>". */
739 expand_location (source_location loc
)
741 return expand_location_1 (loc
, /*expansion_point_p=*/true);
744 /* Expand the source location LOC into a human readable location. If
745 LOC is virtual, it resolves to the expansion location of the
746 relevant macro. If LOC resolves to a builtin location, the file
747 name of the readable location is set to the string
751 expand_location_to_spelling_point (source_location loc
)
753 return expand_location_1 (loc
, /*expansion_point_p=*/false);
756 /* The rich_location class within libcpp requires a way to expand
757 source_location instances, and relies on the client code
758 providing a symbol named
759 linemap_client_expand_location_to_spelling_point
762 This is the implementation for libcommon.a (all host binaries),
763 which simply calls into expand_location_to_spelling_point. */
766 linemap_client_expand_location_to_spelling_point (source_location loc
)
768 return expand_location_to_spelling_point (loc
);
772 /* If LOCATION is in a system header and if it is a virtual location for
773 a token coming from the expansion of a macro, unwind it to the
774 location of the expansion point of the macro. Otherwise, just return
777 This is used for instance when we want to emit diagnostics about a
778 token that may be located in a macro that is itself defined in a
779 system header, for example, for the NULL macro. In such a case, if
780 LOCATION were passed directly to diagnostic functions such as
781 warning_at, the diagnostic would be suppressed (unless
782 -Wsystem-headers). */
785 expansion_point_location_if_in_system_header (source_location location
)
787 if (in_system_header_at (location
))
788 location
= linemap_resolve_location (line_table
, location
,
789 LRK_MACRO_EXPANSION_POINT
,
794 /* If LOCATION is a virtual location for a token coming from the expansion
795 of a macro, unwind to the location of the expansion point of the macro. */
798 expansion_point_location (source_location location
)
800 return linemap_resolve_location (line_table
, location
,
801 LRK_MACRO_EXPANSION_POINT
, NULL
);
804 /* Given location LOC, strip away any packed range information
805 or ad-hoc information. */
808 get_pure_location (location_t loc
)
810 if (IS_ADHOC_LOC (loc
))
812 = line_table
->location_adhoc_data_map
.data
[loc
& MAX_SOURCE_LOCATION
].locus
;
814 if (loc
>= LINEMAPS_MACRO_LOWEST_LOCATION (line_table
))
817 if (loc
< RESERVED_LOCATION_COUNT
)
820 const line_map
*map
= linemap_lookup (line_table
, loc
);
821 const line_map_ordinary
*ordmap
= linemap_check_ordinary (map
);
823 return loc
& ~((1 << ordmap
->m_range_bits
) - 1);
826 /* Construct a location with caret at CARET, ranging from START to
832 523 return foo + bar;
836 The location's caret is at the "+", line 523 column 15, but starts
837 earlier, at the "f" of "foo" at column 11. The finish is at the "r"
838 of "bar" at column 19. */
841 make_location (location_t caret
, location_t start
, location_t finish
)
843 location_t pure_loc
= get_pure_location (caret
);
844 source_range src_range
;
845 src_range
.m_start
= start
;
846 src_range
.m_finish
= finish
;
847 location_t combined_loc
= COMBINE_LOCATION_DATA (line_table
,
855 #define ONE_M (ONE_K * ONE_K)
857 /* Display a number as an integer multiple of either:
858 - 1024, if said integer is >= to 10 K (in base 2)
859 - 1024 * 1024, if said integer is >= 10 M in (base 2)
861 #define SCALE(x) ((unsigned long) ((x) < 10 * ONE_K \
863 : ((x) < 10 * ONE_M \
867 /* For a given integer, display either:
868 - the character 'k', if the number is higher than 10 K (in base 2)
869 but strictly lower than 10 M (in base 2)
870 - the character 'M' if the number is higher than 10 M (in base2)
871 - the charcter ' ' if the number is strictly lower than 10 K */
872 #define STAT_LABEL(x) ((x) < 10 * ONE_K ? ' ' : ((x) < 10 * ONE_M ? 'k' : 'M'))
874 /* Display an integer amount as multiple of 1K or 1M (in base 2).
875 Display the correct unit (either k, M, or ' ') after the amout, as
877 #define FORMAT_AMOUNT(size) SCALE (size), STAT_LABEL (size)
879 /* Dump statistics to stderr about the memory usage of the line_table
880 set of line maps. This also displays some statistics about macro
884 dump_line_table_statistics (void)
886 struct linemap_stats s
;
887 long total_used_map_size
,
889 total_allocated_map_size
;
891 memset (&s
, 0, sizeof (s
));
893 linemap_get_statistics (line_table
, &s
);
895 macro_maps_size
= s
.macro_maps_used_size
896 + s
.macro_maps_locations_size
;
898 total_allocated_map_size
= s
.ordinary_maps_allocated_size
899 + s
.macro_maps_allocated_size
900 + s
.macro_maps_locations_size
;
902 total_used_map_size
= s
.ordinary_maps_used_size
903 + s
.macro_maps_used_size
904 + s
.macro_maps_locations_size
;
906 fprintf (stderr
, "Number of expanded macros: %5ld\n",
907 s
.num_expanded_macros
);
908 if (s
.num_expanded_macros
!= 0)
909 fprintf (stderr
, "Average number of tokens per macro expansion: %5ld\n",
910 s
.num_macro_tokens
/ s
.num_expanded_macros
);
912 "\nLine Table allocations during the "
913 "compilation process\n");
914 fprintf (stderr
, "Number of ordinary maps used: %5ld%c\n",
915 SCALE (s
.num_ordinary_maps_used
),
916 STAT_LABEL (s
.num_ordinary_maps_used
));
917 fprintf (stderr
, "Ordinary map used size: %5ld%c\n",
918 SCALE (s
.ordinary_maps_used_size
),
919 STAT_LABEL (s
.ordinary_maps_used_size
));
920 fprintf (stderr
, "Number of ordinary maps allocated: %5ld%c\n",
921 SCALE (s
.num_ordinary_maps_allocated
),
922 STAT_LABEL (s
.num_ordinary_maps_allocated
));
923 fprintf (stderr
, "Ordinary maps allocated size: %5ld%c\n",
924 SCALE (s
.ordinary_maps_allocated_size
),
925 STAT_LABEL (s
.ordinary_maps_allocated_size
));
926 fprintf (stderr
, "Number of macro maps used: %5ld%c\n",
927 SCALE (s
.num_macro_maps_used
),
928 STAT_LABEL (s
.num_macro_maps_used
));
929 fprintf (stderr
, "Macro maps used size: %5ld%c\n",
930 SCALE (s
.macro_maps_used_size
),
931 STAT_LABEL (s
.macro_maps_used_size
));
932 fprintf (stderr
, "Macro maps locations size: %5ld%c\n",
933 SCALE (s
.macro_maps_locations_size
),
934 STAT_LABEL (s
.macro_maps_locations_size
));
935 fprintf (stderr
, "Macro maps size: %5ld%c\n",
936 SCALE (macro_maps_size
),
937 STAT_LABEL (macro_maps_size
));
938 fprintf (stderr
, "Duplicated maps locations size: %5ld%c\n",
939 SCALE (s
.duplicated_macro_maps_locations_size
),
940 STAT_LABEL (s
.duplicated_macro_maps_locations_size
));
941 fprintf (stderr
, "Total allocated maps size: %5ld%c\n",
942 SCALE (total_allocated_map_size
),
943 STAT_LABEL (total_allocated_map_size
));
944 fprintf (stderr
, "Total used maps size: %5ld%c\n",
945 SCALE (total_used_map_size
),
946 STAT_LABEL (total_used_map_size
));
947 fprintf (stderr
, "Ad-hoc table size: %5ld%c\n",
948 SCALE (s
.adhoc_table_size
),
949 STAT_LABEL (s
.adhoc_table_size
));
950 fprintf (stderr
, "Ad-hoc table entries used: %5ld\n",
951 s
.adhoc_table_entries_used
);
952 fprintf (stderr
, "optimized_ranges: %i\n",
953 line_table
->num_optimized_ranges
);
954 fprintf (stderr
, "unoptimized_ranges: %i\n",
955 line_table
->num_unoptimized_ranges
);
957 fprintf (stderr
, "\n");
960 /* Get location one beyond the final location in ordinary map IDX. */
962 static source_location
963 get_end_location (struct line_maps
*set
, unsigned int idx
)
965 if (idx
== LINEMAPS_ORDINARY_USED (set
) - 1)
966 return set
->highest_location
;
968 struct line_map
*next_map
= LINEMAPS_ORDINARY_MAP_AT (set
, idx
+ 1);
969 return MAP_START_LOCATION (next_map
);
972 /* Helper function for write_digit_row. */
975 write_digit (FILE *stream
, int digit
)
977 fputc ('0' + (digit
% 10), stream
);
980 /* Helper function for dump_location_info.
981 Write a row of numbers to STREAM, numbering a source line,
982 giving the units, tens, hundreds etc of the column number. */
985 write_digit_row (FILE *stream
, int indent
,
986 const line_map_ordinary
*map
,
987 source_location loc
, int max_col
, int divisor
)
989 fprintf (stream
, "%*c", indent
, ' ');
990 fprintf (stream
, "|");
991 for (int column
= 1; column
< max_col
; column
++)
993 source_location column_loc
= loc
+ (column
<< map
->m_range_bits
);
994 write_digit (stream
, column_loc
/ divisor
);
996 fprintf (stream
, "\n");
999 /* Write a half-closed (START) / half-open (END) interval of
1000 source_location to STREAM. */
1003 dump_location_range (FILE *stream
,
1004 source_location start
, source_location end
)
1007 " source_location interval: %u <= loc < %u\n",
1011 /* Write a labelled description of a half-closed (START) / half-open (END)
1012 interval of source_location to STREAM. */
1015 dump_labelled_location_range (FILE *stream
,
1017 source_location start
, source_location end
)
1019 fprintf (stream
, "%s\n", name
);
1020 dump_location_range (stream
, start
, end
);
1021 fprintf (stream
, "\n");
1024 /* Write a visualization of the locations in the line_table to STREAM. */
1027 dump_location_info (FILE *stream
)
1029 /* Visualize the reserved locations. */
1030 dump_labelled_location_range (stream
, "RESERVED LOCATIONS",
1031 0, RESERVED_LOCATION_COUNT
);
1033 /* Visualize the ordinary line_map instances, rendering the sources. */
1034 for (unsigned int idx
= 0; idx
< LINEMAPS_ORDINARY_USED (line_table
); idx
++)
1036 source_location end_location
= get_end_location (line_table
, idx
);
1037 /* half-closed: doesn't include this one. */
1039 const line_map_ordinary
*map
1040 = LINEMAPS_ORDINARY_MAP_AT (line_table
, idx
);
1041 fprintf (stream
, "ORDINARY MAP: %i\n", idx
);
1042 dump_location_range (stream
,
1043 MAP_START_LOCATION (map
), end_location
);
1044 fprintf (stream
, " file: %s\n", ORDINARY_MAP_FILE_NAME (map
));
1045 fprintf (stream
, " starting at line: %i\n",
1046 ORDINARY_MAP_STARTING_LINE_NUMBER (map
));
1047 fprintf (stream
, " column and range bits: %i\n",
1048 map
->m_column_and_range_bits
);
1049 fprintf (stream
, " column bits: %i\n",
1050 map
->m_column_and_range_bits
- map
->m_range_bits
);
1051 fprintf (stream
, " range bits: %i\n",
1054 /* Render the span of source lines that this "map" covers. */
1055 for (source_location loc
= MAP_START_LOCATION (map
);
1057 loc
+= (1 << map
->m_range_bits
) )
1059 gcc_assert (pure_location_p (line_table
, loc
) );
1061 expanded_location exploc
1062 = linemap_expand_location (line_table
, map
, loc
);
1064 if (0 == exploc
.column
)
1066 /* Beginning of a new source line: draw the line. */
1069 const char *line_text
= location_get_source_line (exploc
.file
,
1075 "%s:%3i|loc:%5i|%.*s\n",
1076 exploc
.file
, exploc
.line
,
1078 line_size
, line_text
);
1080 /* "loc" is at column 0, which means "the whole line".
1081 Render the locations *within* the line, by underlining
1082 it, showing the source_location numeric values
1084 int max_col
= (1 << map
->m_column_and_range_bits
) - 1;
1085 if (max_col
> line_size
)
1086 max_col
= line_size
+ 1;
1088 int indent
= 14 + strlen (exploc
.file
);
1091 if (end_location
> 999)
1092 write_digit_row (stream
, indent
, map
, loc
, max_col
, 1000);
1095 if (end_location
> 99)
1096 write_digit_row (stream
, indent
, map
, loc
, max_col
, 100);
1099 write_digit_row (stream
, indent
, map
, loc
, max_col
, 10);
1102 write_digit_row (stream
, indent
, map
, loc
, max_col
, 1);
1105 fprintf (stream
, "\n");
1108 /* Visualize unallocated values. */
1109 dump_labelled_location_range (stream
, "UNALLOCATED LOCATIONS",
1110 line_table
->highest_location
,
1111 LINEMAPS_MACRO_LOWEST_LOCATION (line_table
));
1113 /* Visualize the macro line_map instances, rendering the sources. */
1114 for (unsigned int i
= 0; i
< LINEMAPS_MACRO_USED (line_table
); i
++)
1116 /* Each macro map that is allocated owns source_location values
1117 that are *lower* that the one before them.
1118 Hence it's meaningful to view them either in order of ascending
1119 source locations, or in order of ascending macro map index. */
1120 const bool ascending_source_locations
= true;
1121 unsigned int idx
= (ascending_source_locations
1122 ? (LINEMAPS_MACRO_USED (line_table
) - (i
+ 1))
1124 const line_map_macro
*map
= LINEMAPS_MACRO_MAP_AT (line_table
, idx
);
1125 fprintf (stream
, "MACRO %i: %s (%u tokens)\n",
1127 linemap_map_get_macro_name (map
),
1128 MACRO_MAP_NUM_MACRO_TOKENS (map
));
1129 dump_location_range (stream
,
1130 map
->start_location
,
1131 (map
->start_location
1132 + MACRO_MAP_NUM_MACRO_TOKENS (map
)));
1133 inform (MACRO_MAP_EXPANSION_POINT_LOCATION (map
),
1134 "expansion point is location %i",
1135 MACRO_MAP_EXPANSION_POINT_LOCATION (map
));
1136 fprintf (stream
, " map->start_location: %u\n",
1137 map
->start_location
);
1139 fprintf (stream
, " macro_locations:\n");
1140 for (unsigned int i
= 0; i
< MACRO_MAP_NUM_MACRO_TOKENS (map
); i
++)
1142 source_location x
= MACRO_MAP_LOCATIONS (map
)[2 * i
];
1143 source_location y
= MACRO_MAP_LOCATIONS (map
)[(2 * i
) + 1];
1145 /* linemap_add_macro_token encodes token numbers in an expansion
1146 by putting them after MAP_START_LOCATION. */
1148 /* I'm typically seeing 4 uninitialized entries at the end of
1150 This appears to be due to macro.c:replace_args
1151 adding 2 extra args for padding tokens; presumably there may
1152 be a leading and/or trailing padding token injected,
1153 each for 2 more location slots.
1154 This would explain there being up to 4 source_locations slots
1155 that may be uninitialized. */
1157 fprintf (stream
, " %u: %u, %u\n",
1163 if (x
< MAP_START_LOCATION (map
))
1164 inform (x
, "token %u has x-location == y-location == %u", i
, x
);
1167 "x-location == y-location == %u encodes token # %u\n",
1168 x
, x
- MAP_START_LOCATION (map
));
1172 inform (x
, "token %u has x-location == %u", i
, x
);
1173 inform (x
, "token %u has y-location == %u", i
, y
);
1176 fprintf (stream
, "\n");
1179 /* It appears that MAX_SOURCE_LOCATION itself is never assigned to a
1180 macro map, presumably due to an off-by-one error somewhere
1181 between the logic in linemap_enter_macro and
1182 LINEMAPS_MACRO_LOWEST_LOCATION. */
1183 dump_labelled_location_range (stream
, "MAX_SOURCE_LOCATION",
1184 MAX_SOURCE_LOCATION
,
1185 MAX_SOURCE_LOCATION
+ 1);
1187 /* Visualize ad-hoc values. */
1188 dump_labelled_location_range (stream
, "AD-HOC LOCATIONS",
1189 MAX_SOURCE_LOCATION
+ 1, UINT_MAX
);
1194 namespace selftest
{
1196 /* Selftests of location handling. */
1198 /* A class for writing out a temporary sourcefile for use in selftests
1199 of input handling. */
1201 class temp_source_file
1204 temp_source_file (const location
&loc
, const char *suffix
,
1205 const char *content
);
1206 ~temp_source_file ();
1208 const char *get_filename () const { return m_filename
; }
1214 /* Constructor. Create a tempfile using SUFFIX, and write CONTENT to
1215 it. Abort if anything goes wrong, using LOC as the effective
1216 location in the problem report. */
1218 temp_source_file::temp_source_file (const location
&loc
, const char *suffix
,
1219 const char *content
)
1221 m_filename
= make_temp_file (suffix
);
1222 ASSERT_NE (m_filename
, NULL
);
1224 FILE *out
= fopen (m_filename
, "w");
1226 ::selftest::fail_formatted (loc
, "unable to open tempfile: %s",
1228 fprintf (out
, "%s", content
);
1232 /* Destructor. Delete the tempfile. */
1234 temp_source_file::~temp_source_file ()
1236 unlink (m_filename
);
1240 /* Helper function for verifying location data: when location_t
1241 values are > LINE_MAP_MAX_LOCATION_WITH_COLS, they are treated
1242 as having column 0. */
1245 should_have_column_data_p (location_t loc
)
1247 if (IS_ADHOC_LOC (loc
))
1248 loc
= get_location_from_adhoc_loc (line_table
, loc
);
1249 if (loc
> LINE_MAP_MAX_LOCATION_WITH_COLS
)
1254 /* Selftest for should_have_column_data_p. */
1257 test_should_have_column_data_p ()
1259 ASSERT_TRUE (should_have_column_data_p (RESERVED_LOCATION_COUNT
));
1261 (should_have_column_data_p (LINE_MAP_MAX_LOCATION_WITH_COLS
));
1263 (should_have_column_data_p (LINE_MAP_MAX_LOCATION_WITH_COLS
+ 1));
1266 /* Verify the result of LOCATION_FILE/LOCATION_LINE/LOCATION_COLUMN
1270 assert_loceq (const char *exp_filename
, int exp_linenum
, int exp_colnum
,
1273 ASSERT_STREQ (exp_filename
, LOCATION_FILE (loc
));
1274 ASSERT_EQ (exp_linenum
, LOCATION_LINE (loc
));
1275 /* If location_t values are sufficiently high, then column numbers
1276 will be unavailable and LOCATION_COLUMN (loc) will be 0.
1277 When close to the threshold, column numbers *may* be present: if
1278 the final linemap before the threshold contains a line that straddles
1279 the threshold, locations in that line have column information. */
1280 if (should_have_column_data_p (loc
))
1281 ASSERT_EQ (exp_colnum
, LOCATION_COLUMN (loc
));
1284 /* Various selftests in this file involve constructing a line table
1285 and one or more line maps within it.
1287 For maximum test coverage we want to run these tests with a variety
1289 - line_table->default_range_bits: some frontends use a non-zero value
1291 - the fallback modes within line-map.c: there are various threshold
1292 values for source_location/location_t beyond line-map.c changes
1293 behavior (disabling of the range-packing optimization, disabling
1294 of column-tracking). We can exercise these by starting the line_table
1295 at interesting values at or near these thresholds.
1297 The following struct describes a particular case within our test
1300 struct line_table_case
1302 line_table_case (int default_range_bits
, int base_location
)
1303 : m_default_range_bits (default_range_bits
),
1304 m_base_location (base_location
)
1307 int m_default_range_bits
;
1308 int m_base_location
;
1311 /* A class for overriding the global "line_table" within a selftest,
1312 restoring its value afterwards. */
1314 class temp_line_table
1317 temp_line_table (const line_table_case
&);
1318 ~temp_line_table ();
1321 line_maps
*m_old_line_table
;
1324 /* Constructor. Store the old value of line_table, and create a new
1325 one, using the sitation described in CASE_. */
1327 temp_line_table::temp_line_table (const line_table_case
&case_
)
1328 : m_old_line_table (line_table
)
1330 line_table
= ggc_alloc
<line_maps
> ();
1331 linemap_init (line_table
, BUILTINS_LOCATION
);
1332 line_table
->reallocator
= m_old_line_table
->reallocator
;
1333 line_table
->round_alloc_size
= m_old_line_table
->round_alloc_size
;
1334 line_table
->default_range_bits
= case_
.m_default_range_bits
;
1335 if (case_
.m_base_location
)
1337 line_table
->highest_location
= case_
.m_base_location
;
1338 line_table
->highest_line
= case_
.m_base_location
;
1342 /* Destructor. Restore the old value of line_table. */
1344 temp_line_table::~temp_line_table ()
1346 line_table
= m_old_line_table
;
1349 /* Verify basic operation of ordinary linemaps. */
1352 test_accessing_ordinary_linemaps (const line_table_case
&case_
)
1354 temp_line_table
tmp_lt (case_
);
1356 /* Build a simple linemap describing some locations. */
1357 linemap_add (line_table
, LC_ENTER
, false, "foo.c", 0);
1359 linemap_line_start (line_table
, 1, 100);
1360 location_t loc_a
= linemap_position_for_column (line_table
, 1);
1361 location_t loc_b
= linemap_position_for_column (line_table
, 23);
1363 linemap_line_start (line_table
, 2, 100);
1364 location_t loc_c
= linemap_position_for_column (line_table
, 1);
1365 location_t loc_d
= linemap_position_for_column (line_table
, 17);
1367 /* Example of a very long line. */
1368 linemap_line_start (line_table
, 3, 2000);
1369 location_t loc_e
= linemap_position_for_column (line_table
, 700);
1371 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1373 /* Multiple files. */
1374 linemap_add (line_table
, LC_ENTER
, false, "bar.c", 0);
1375 linemap_line_start (line_table
, 1, 200);
1376 location_t loc_f
= linemap_position_for_column (line_table
, 150);
1377 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1379 /* Verify that we can recover the location info. */
1380 assert_loceq ("foo.c", 1, 1, loc_a
);
1381 assert_loceq ("foo.c", 1, 23, loc_b
);
1382 assert_loceq ("foo.c", 2, 1, loc_c
);
1383 assert_loceq ("foo.c", 2, 17, loc_d
);
1384 assert_loceq ("foo.c", 3, 700, loc_e
);
1385 assert_loceq ("bar.c", 1, 150, loc_f
);
1387 ASSERT_FALSE (is_location_from_builtin_token (loc_a
));
1388 ASSERT_TRUE (pure_location_p (line_table
, loc_a
));
1390 /* Verify using make_location to build a range, and extracting data
1392 location_t range_c_b_d
= make_location (loc_c
, loc_b
, loc_d
);
1393 ASSERT_FALSE (pure_location_p (line_table
, range_c_b_d
));
1394 ASSERT_EQ (loc_c
, get_location_from_adhoc_loc (line_table
, range_c_b_d
));
1395 source_range src_range
= get_range_from_loc (line_table
, range_c_b_d
);
1396 ASSERT_EQ (loc_b
, src_range
.m_start
);
1397 ASSERT_EQ (loc_d
, src_range
.m_finish
);
1400 /* Verify various properties of UNKNOWN_LOCATION. */
1403 test_unknown_location ()
1405 ASSERT_EQ (NULL
, LOCATION_FILE (UNKNOWN_LOCATION
));
1406 ASSERT_EQ (0, LOCATION_LINE (UNKNOWN_LOCATION
));
1407 ASSERT_EQ (0, LOCATION_COLUMN (UNKNOWN_LOCATION
));
1410 /* Verify various properties of BUILTINS_LOCATION. */
1415 assert_loceq (_("<built-in>"), 0, 0, BUILTINS_LOCATION
);
1416 ASSERT_PRED1 (is_location_from_builtin_token
, BUILTINS_LOCATION
);
1419 /* Verify reading of input files (e.g. for caret-based diagnostics). */
1422 test_reading_source_line ()
1424 /* Create a tempfile and write some text to it. */
1425 temp_source_file
tmp (SELFTEST_LOCATION
, ".txt",
1426 "01234567890123456789\n"
1427 "This is the test text\n"
1428 "This is the 3rd line\n");
1430 /* Read back a specific line from the tempfile. */
1432 const char *source_line
= location_get_source_line (tmp
.get_filename (),
1434 ASSERT_TRUE (source_line
!= NULL
);
1435 ASSERT_EQ (21, line_size
);
1436 if (!strncmp ("This is the test text",
1437 source_line
, line_size
))
1438 ::selftest::pass (SELFTEST_LOCATION
,
1439 "source_line matched expected value");
1441 ::selftest::fail (SELFTEST_LOCATION
,
1442 "source_line did not match expected value");
1446 /* Tests of lexing. */
1448 /* Verify that token TOK from PARSER has cpp_token_as_text
1449 equal to EXPECTED_TEXT. */
1451 #define ASSERT_TOKEN_AS_TEXT_EQ(PARSER, TOK, EXPECTED_TEXT) \
1452 SELFTEST_BEGIN_STMT \
1453 unsigned char *actual_txt = cpp_token_as_text ((PARSER), (TOK)); \
1454 ASSERT_STREQ ((EXPECTED_TEXT), (const char *)actual_txt); \
1457 /* Verify that TOK's src_loc is within EXP_FILENAME at EXP_LINENUM,
1458 and ranges from EXP_START_COL to EXP_FINISH_COL.
1459 Use LOC as the effective location of the selftest. */
1462 assert_token_loc_eq (const location
&loc
,
1463 const cpp_token
*tok
,
1464 const char *exp_filename
, int exp_linenum
,
1465 int exp_start_col
, int exp_finish_col
)
1467 location_t tok_loc
= tok
->src_loc
;
1468 ASSERT_STREQ_AT (loc
, exp_filename
, LOCATION_FILE (tok_loc
));
1469 ASSERT_EQ_AT (loc
, exp_linenum
, LOCATION_LINE (tok_loc
));
1471 /* If location_t values are sufficiently high, then column numbers
1472 will be unavailable. */
1473 if (!should_have_column_data_p (tok_loc
))
1476 ASSERT_EQ_AT (loc
, exp_start_col
, LOCATION_COLUMN (tok_loc
));
1477 source_range tok_range
= get_range_from_loc (line_table
, tok_loc
);
1478 ASSERT_EQ_AT (loc
, exp_start_col
, LOCATION_COLUMN (tok_range
.m_start
));
1479 ASSERT_EQ_AT (loc
, exp_finish_col
, LOCATION_COLUMN (tok_range
.m_finish
));
1482 /* Use assert_token_loc_eq to verify the TOK->src_loc, using
1483 SELFTEST_LOCATION as the effective location of the selftest. */
1485 #define ASSERT_TOKEN_LOC_EQ(TOK, EXP_FILENAME, EXP_LINENUM, \
1486 EXP_START_COL, EXP_FINISH_COL) \
1487 assert_token_loc_eq (SELFTEST_LOCATION, (TOK), (EXP_FILENAME), \
1488 (EXP_LINENUM), (EXP_START_COL), (EXP_FINISH_COL))
1490 /* Test of lexing a file using libcpp, verifying tokens and their
1491 location information. */
1494 test_lexer (const line_table_case
&case_
)
1496 /* Create a tempfile and write some text to it. */
1497 const char *content
=
1498 /*00000000011111111112222222222333333.3333444444444.455555555556
1499 12345678901234567890123456789012345.6789012345678.901234567890. */
1500 ("test_name /* c-style comment */\n"
1501 " \"test literal\"\n"
1502 " // test c++-style comment\n"
1504 temp_source_file
tmp (SELFTEST_LOCATION
, ".txt", content
);
1506 temp_line_table
tmp_lt (case_
);
1508 cpp_reader
*parser
= cpp_create_reader (CLK_GNUC89
, NULL
, line_table
);
1510 const char *fname
= cpp_read_main_file (parser
, tmp
.get_filename ());
1511 ASSERT_NE (fname
, NULL
);
1513 /* Verify that we get the expected tokens back, with the correct
1514 location information. */
1517 const cpp_token
*tok
;
1518 tok
= cpp_get_token_with_location (parser
, &loc
);
1519 ASSERT_NE (tok
, NULL
);
1520 ASSERT_EQ (tok
->type
, CPP_NAME
);
1521 ASSERT_TOKEN_AS_TEXT_EQ (parser
, tok
, "test_name");
1522 ASSERT_TOKEN_LOC_EQ (tok
, tmp
.get_filename (), 1, 1, 9);
1524 tok
= cpp_get_token_with_location (parser
, &loc
);
1525 ASSERT_NE (tok
, NULL
);
1526 ASSERT_EQ (tok
->type
, CPP_STRING
);
1527 ASSERT_TOKEN_AS_TEXT_EQ (parser
, tok
, "\"test literal\"");
1528 ASSERT_TOKEN_LOC_EQ (tok
, tmp
.get_filename (), 2, 35, 48);
1530 tok
= cpp_get_token_with_location (parser
, &loc
);
1531 ASSERT_NE (tok
, NULL
);
1532 ASSERT_EQ (tok
->type
, CPP_NUMBER
);
1533 ASSERT_TOKEN_AS_TEXT_EQ (parser
, tok
, "42");
1534 ASSERT_TOKEN_LOC_EQ (tok
, tmp
.get_filename (), 4, 4, 5);
1536 tok
= cpp_get_token_with_location (parser
, &loc
);
1537 ASSERT_NE (tok
, NULL
);
1538 ASSERT_EQ (tok
->type
, CPP_EOF
);
1540 cpp_finish (parser
, NULL
);
1541 cpp_destroy (parser
);
1544 /* A table of interesting location_t values, giving one axis of our test
1547 static const location_t boundary_locations
[] = {
1548 /* Zero means "don't override the default values for a new line_table". */
1551 /* An arbitrary non-zero value that isn't close to one of
1552 the boundary values below. */
1555 /* Values near LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES. */
1556 LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
- 0x100,
1557 LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
- 1,
1558 LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
,
1559 LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
+ 1,
1560 LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES
+ 0x100,
1562 /* Values near LINE_MAP_MAX_LOCATION_WITH_COLS. */
1563 LINE_MAP_MAX_LOCATION_WITH_COLS
- 0x100,
1564 LINE_MAP_MAX_LOCATION_WITH_COLS
- 1,
1565 LINE_MAP_MAX_LOCATION_WITH_COLS
,
1566 LINE_MAP_MAX_LOCATION_WITH_COLS
+ 1,
1567 LINE_MAP_MAX_LOCATION_WITH_COLS
+ 0x100,
1570 /* Run all of the selftests within this file. */
1575 test_should_have_column_data_p ();
1576 test_unknown_location ();
1579 /* As noted above in the description of struct line_table_case,
1580 we want to explore a test matrix of interesting line_table
1581 situations, running various selftests for each case within the
1584 /* Run all tests with:
1585 (a) line_table->default_range_bits == 0, and
1586 (b) line_table->default_range_bits == 5. */
1587 int num_cases_tested
= 0;
1588 for (int default_range_bits
= 0; default_range_bits
<= 5;
1589 default_range_bits
+= 5)
1591 /* ...and use each of the "interesting" location values as
1592 the starting location within line_table. */
1593 const int num_boundary_locations
1594 = sizeof (boundary_locations
) / sizeof (boundary_locations
[0]);
1595 for (int loc_idx
= 0; loc_idx
< num_boundary_locations
; loc_idx
++)
1597 line_table_case
c (default_range_bits
, boundary_locations
[loc_idx
]);
1599 /* Run all tests for the given case within the test matrix. */
1600 test_accessing_ordinary_linemaps (c
);
1607 /* Verify that we fully covered the test matrix. */
1608 ASSERT_EQ (num_cases_tested
, 2 * 12);
1610 test_reading_source_line ();
1613 } // namespace selftest
1615 #endif /* CHECKING_P */