1 |
730 |
jeremybenn |
/* Map logical line numbers to (source file, line number) pairs.
|
2 |
|
|
Copyright (C) 2001, 2003, 2004, 2007, 2008, 2009, 2010, 2011
|
3 |
|
|
Free Software Foundation, Inc.
|
4 |
|
|
|
5 |
|
|
This program is free software; you can redistribute it and/or modify it
|
6 |
|
|
under the terms of the GNU General Public License as published by the
|
7 |
|
|
Free Software Foundation; either version 3, or (at your option) any
|
8 |
|
|
later version.
|
9 |
|
|
|
10 |
|
|
This program is distributed in the hope that it will be useful,
|
11 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
12 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
13 |
|
|
GNU General Public License for more details.
|
14 |
|
|
|
15 |
|
|
You should have received a copy of the GNU General Public License
|
16 |
|
|
along with this program; see the file COPYING3. If not see
|
17 |
|
|
<http://www.gnu.org/licenses/>.
|
18 |
|
|
|
19 |
|
|
In other words, you are welcome to use, share and improve this program.
|
20 |
|
|
You are forbidden to forbid anyone else to use, share and improve
|
21 |
|
|
what you give them. Help stamp out software-hoarding! */
|
22 |
|
|
|
23 |
|
|
#ifndef LIBCPP_LINE_MAP_H
|
24 |
|
|
#define LIBCPP_LINE_MAP_H
|
25 |
|
|
|
26 |
|
|
#ifndef GTY
|
27 |
|
|
#define GTY(x) /* nothing */
|
28 |
|
|
#endif
|
29 |
|
|
|
30 |
|
|
/* Reason for creating a new line map with linemap_add. LC_ENTER is
|
31 |
|
|
when including a new file, e.g. a #include directive in C.
|
32 |
|
|
LC_LEAVE is when reaching a file's end. LC_RENAME is when a file
|
33 |
|
|
name or line number changes for neither of the above reasons
|
34 |
|
|
(e.g. a #line directive in C); LC_RENAME_VERBATIM is like LC_RENAME
|
35 |
|
|
but a filename of "" is not specially interpreted as standard
|
36 |
|
|
input. LC_ENTER_MACRO is when a macro expansion is about to start. */
|
37 |
|
|
enum lc_reason
|
38 |
|
|
{
|
39 |
|
|
LC_ENTER = 0,
|
40 |
|
|
LC_LEAVE,
|
41 |
|
|
LC_RENAME,
|
42 |
|
|
LC_RENAME_VERBATIM,
|
43 |
|
|
LC_ENTER_MACRO
|
44 |
|
|
/* FIXME: add support for stringize and paste. */
|
45 |
|
|
};
|
46 |
|
|
|
47 |
|
|
/* The type of line numbers. */
|
48 |
|
|
typedef unsigned int linenum_type;
|
49 |
|
|
|
50 |
|
|
/* A logical line/column number, i.e. an "index" into a line_map. */
|
51 |
|
|
typedef unsigned int source_location;
|
52 |
|
|
|
53 |
|
|
/* Memory allocation function typedef. Works like xrealloc. */
|
54 |
|
|
typedef void *(*line_map_realloc) (void *, size_t);
|
55 |
|
|
|
56 |
|
|
/* Memory allocator function that returns the actual allocated size,
|
57 |
|
|
for a given requested allocation. */
|
58 |
|
|
typedef size_t (*line_map_round_alloc_size_func) (size_t);
|
59 |
|
|
|
60 |
|
|
/* An ordinary line map encodes physical source locations. Those
|
61 |
|
|
physical source locations are called "spelling locations".
|
62 |
|
|
|
63 |
|
|
Physical source file TO_FILE at line TO_LINE at column 0 is represented
|
64 |
|
|
by the logical START_LOCATION. TO_LINE+L at column C is represented by
|
65 |
|
|
START_LOCATION+(L*(1<<column_bits))+C, as long as C<(1<<column_bits),
|
66 |
|
|
and the result_location is less than the next line_map's start_location.
|
67 |
|
|
(The top line is line 1 and the leftmost column is column 1; line/column 0
|
68 |
|
|
means "entire file/line" or "unknown line/column" or "not applicable".)
|
69 |
|
|
|
70 |
|
|
The highest possible source location is MAX_SOURCE_LOCATION. */
|
71 |
|
|
struct GTY(()) line_map_ordinary {
|
72 |
|
|
const char *to_file;
|
73 |
|
|
linenum_type to_line;
|
74 |
|
|
|
75 |
|
|
/* An index into the set that gives the line mapping at whose end
|
76 |
|
|
the current one was included. File(s) at the bottom of the
|
77 |
|
|
include stack have this set to -1. */
|
78 |
|
|
int included_from;
|
79 |
|
|
|
80 |
|
|
/* SYSP is one for a system header, two for a C system header file
|
81 |
|
|
that therefore needs to be extern "C" protected in C++, and zero
|
82 |
|
|
otherwise. This field isn't really needed now that it's in
|
83 |
|
|
cpp_buffer. */
|
84 |
|
|
unsigned char sysp;
|
85 |
|
|
|
86 |
|
|
/* Number of the low-order source_location bits used for a column number. */
|
87 |
|
|
unsigned int column_bits : 8;
|
88 |
|
|
};
|
89 |
|
|
|
90 |
|
|
/* This is the highest possible source location encoded within an
|
91 |
|
|
ordinary or macro map. */
|
92 |
|
|
#define MAX_SOURCE_LOCATION 0xFFFFFFFF
|
93 |
|
|
|
94 |
|
|
struct cpp_hashnode;
|
95 |
|
|
|
96 |
|
|
/* A macro line map encodes location of tokens coming from a macro
|
97 |
|
|
expansion.
|
98 |
|
|
|
99 |
|
|
Please note that this struct line_map_macro is a field of struct
|
100 |
|
|
line_map below, go read the comments of struct line_map below and
|
101 |
|
|
then come back here.
|
102 |
|
|
|
103 |
|
|
The offset from START_LOCATION is used to index into
|
104 |
|
|
MACRO_LOCATIONS; this holds the original location of the token. */
|
105 |
|
|
struct GTY(()) line_map_macro {
|
106 |
|
|
/* The cpp macro which expansion gave birth to this macro map. */
|
107 |
|
|
struct cpp_hashnode * GTY ((nested_ptr (union tree_node,
|
108 |
|
|
"%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
|
109 |
|
|
"%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
|
110 |
|
|
macro;
|
111 |
|
|
|
112 |
|
|
/* The number of tokens inside the replacement-list of MACRO. */
|
113 |
|
|
unsigned int n_tokens;
|
114 |
|
|
|
115 |
|
|
/* This array of location is actually an array of pairs of
|
116 |
|
|
locations. The elements inside it thus look like:
|
117 |
|
|
|
118 |
|
|
x0,y0, x1,y1, x2,y2, ...., xn,yn.
|
119 |
|
|
|
120 |
|
|
where n == n_tokens;
|
121 |
|
|
|
122 |
|
|
Remember that these xI,yI are collected when libcpp is about to
|
123 |
|
|
expand a given macro.
|
124 |
|
|
|
125 |
|
|
yI is the location in the macro definition, either of the token
|
126 |
|
|
itself or of a macro parameter that it replaces.
|
127 |
|
|
|
128 |
|
|
Imagine this:
|
129 |
|
|
|
130 |
|
|
#define PLUS(A, B) A + B <--- #1
|
131 |
|
|
|
132 |
|
|
int a = PLUS (1,2); <--- #2
|
133 |
|
|
|
134 |
|
|
There is a macro map for the expansion of PLUS in #2. PLUS is
|
135 |
|
|
expanded into its expansion-list. The expansion-list is the
|
136 |
|
|
replacement-list of PLUS where the macro parameters are replaced
|
137 |
|
|
with their arguments. So the replacement-list of PLUS is made of
|
138 |
|
|
the tokens:
|
139 |
|
|
|
140 |
|
|
A, +, B
|
141 |
|
|
|
142 |
|
|
and the expansion-list is made of the tokens:
|
143 |
|
|
|
144 |
|
|
1, +, 2
|
145 |
|
|
|
146 |
|
|
Let's consider the case of token "+". Its y1 [yI for I == 1] is
|
147 |
|
|
its spelling location in #1.
|
148 |
|
|
|
149 |
|
|
y0 (thus for token "1") is the spelling location of A in #1.
|
150 |
|
|
|
151 |
|
|
And y2 (of token "2") is the spelling location of B in #1.
|
152 |
|
|
|
153 |
|
|
When the token is /not/ an argument for a macro, xI is the same
|
154 |
|
|
location as yI. Otherwise, xI is the location of the token
|
155 |
|
|
outside this macro expansion. If this macro was expanded from
|
156 |
|
|
another macro expansion, xI is a virtual location representing
|
157 |
|
|
the token in that macro expansion; otherwise, it is the spelling
|
158 |
|
|
location of the token.
|
159 |
|
|
|
160 |
|
|
Note that a virtual location is a location returned by
|
161 |
|
|
linemap_add_macro_token. It encodes the relevant locations (x,y
|
162 |
|
|
pairs) of that token accross the macro expansions from which it
|
163 |
|
|
(the token) might come from.
|
164 |
|
|
|
165 |
|
|
In the example above x1 (for token "+") is going to be the same
|
166 |
|
|
as y1. x0 is the spelling location for the argument token "1",
|
167 |
|
|
and x2 is the spelling location for the argument token "2". */
|
168 |
|
|
source_location * GTY((length ("2 * %h.n_tokens"))) macro_locations;
|
169 |
|
|
|
170 |
|
|
/* This is the location of the expansion point of the current macro
|
171 |
|
|
map. It's the location of the macro name. That location is held
|
172 |
|
|
by the map that was current right before the current one. It
|
173 |
|
|
could have been either a macro or an ordinary map, depending on
|
174 |
|
|
if we are in a nested expansion context not. */
|
175 |
|
|
source_location expansion;
|
176 |
|
|
};
|
177 |
|
|
|
178 |
|
|
/* A line_map encodes a sequence of locations.
|
179 |
|
|
There are two kinds of maps. Ordinary maps and macro expansion
|
180 |
|
|
maps, a.k.a macro maps.
|
181 |
|
|
|
182 |
|
|
A macro map encodes source locations of tokens that are part of a
|
183 |
|
|
macro replacement-list, at a macro expansion point. E.g, in:
|
184 |
|
|
|
185 |
|
|
#define PLUS(A,B) A + B
|
186 |
|
|
|
187 |
|
|
No macro map is going to be created there, because we are not at a
|
188 |
|
|
macro expansion point. We are at a macro /definition/ point. So the
|
189 |
|
|
locations of the tokens of the macro replacement-list (i.e, A + B)
|
190 |
|
|
will be locations in an ordinary map, not a macro map.
|
191 |
|
|
|
192 |
|
|
On the other hand, if we later do:
|
193 |
|
|
|
194 |
|
|
int a = PLUS (1,2);
|
195 |
|
|
|
196 |
|
|
The invocation of PLUS here is a macro expansion. So we are at a
|
197 |
|
|
macro expansion point. The preprocessor expands PLUS (1,2) and
|
198 |
|
|
replaces it with the tokens of its replacement-list: 1 + 2. A macro
|
199 |
|
|
map is going to be created to hold (or rather to map, haha ...) the
|
200 |
|
|
locations of the tokens 1, + and 2. The macro map also records the
|
201 |
|
|
location of the expansion point of PLUS. That location is mapped in
|
202 |
|
|
the map that is active right before the location of the invocation
|
203 |
|
|
of PLUS. */
|
204 |
|
|
struct GTY(()) line_map {
|
205 |
|
|
source_location start_location;
|
206 |
|
|
|
207 |
|
|
/* The reason for creation of this line map. */
|
208 |
|
|
ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
|
209 |
|
|
|
210 |
|
|
union map_u {
|
211 |
|
|
struct line_map_ordinary GTY((tag ("0"))) ordinary;
|
212 |
|
|
struct line_map_macro GTY((tag ("1"))) macro;
|
213 |
|
|
} GTY((desc ("%1.reason == LC_ENTER_MACRO"))) d;
|
214 |
|
|
};
|
215 |
|
|
|
216 |
|
|
#define MAP_START_LOCATION(MAP) (MAP)->start_location
|
217 |
|
|
|
218 |
|
|
#define ORDINARY_MAP_FILE_NAME(MAP) \
|
219 |
|
|
linemap_check_ordinary (MAP)->d.ordinary.to_file
|
220 |
|
|
|
221 |
|
|
#define ORDINARY_MAP_STARTING_LINE_NUMBER(MAP) \
|
222 |
|
|
linemap_check_ordinary (MAP)->d.ordinary.to_line
|
223 |
|
|
|
224 |
|
|
#define ORDINARY_MAP_INCLUDER_FILE_INDEX(MAP) \
|
225 |
|
|
linemap_check_ordinary (MAP)->d.ordinary.included_from
|
226 |
|
|
|
227 |
|
|
#define ORDINARY_MAP_IN_SYSTEM_HEADER_P(MAP) \
|
228 |
|
|
linemap_check_ordinary (MAP)->d.ordinary.sysp
|
229 |
|
|
|
230 |
|
|
#define ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(MAP) \
|
231 |
|
|
linemap_check_ordinary (MAP)->d.ordinary.column_bits
|
232 |
|
|
|
233 |
|
|
#define MACRO_MAP_MACRO(MAP) (MAP)->d.macro.macro
|
234 |
|
|
|
235 |
|
|
#define MACRO_MAP_NUM_MACRO_TOKENS(MAP) (MAP)->d.macro.n_tokens
|
236 |
|
|
|
237 |
|
|
#define MACRO_MAP_LOCATIONS(MAP) (MAP)->d.macro.macro_locations
|
238 |
|
|
|
239 |
|
|
#define MACRO_MAP_EXPANSION_POINT_LOCATION(MAP) (MAP)->d.macro.expansion
|
240 |
|
|
|
241 |
|
|
/* The abstraction of a set of location maps. There can be several
|
242 |
|
|
types of location maps. This abstraction contains the attributes
|
243 |
|
|
that are independent from the type of the map. */
|
244 |
|
|
struct GTY(()) maps_info {
|
245 |
|
|
/* This array contains the different line maps.
|
246 |
|
|
A line map is created for the following events:
|
247 |
|
|
- when a new preprocessing unit start.
|
248 |
|
|
- when a preprocessing unit ends.
|
249 |
|
|
- when a macro expansion occurs. */
|
250 |
|
|
struct line_map * GTY ((length ("%h.used"))) maps;
|
251 |
|
|
|
252 |
|
|
/* The total number of allocated maps. */
|
253 |
|
|
unsigned int allocated;
|
254 |
|
|
|
255 |
|
|
/* The number of elements used in maps. This number is smaller
|
256 |
|
|
or equal to ALLOCATED. */
|
257 |
|
|
unsigned int used;
|
258 |
|
|
|
259 |
|
|
unsigned int cache;
|
260 |
|
|
};
|
261 |
|
|
|
262 |
|
|
/* A set of chronological line_map structures. */
|
263 |
|
|
struct GTY(()) line_maps {
|
264 |
|
|
|
265 |
|
|
struct maps_info info_ordinary;
|
266 |
|
|
|
267 |
|
|
struct maps_info info_macro;
|
268 |
|
|
|
269 |
|
|
/* Depth of the include stack, including the current file. */
|
270 |
|
|
unsigned int depth;
|
271 |
|
|
|
272 |
|
|
/* If true, prints an include trace a la -H. */
|
273 |
|
|
bool trace_includes;
|
274 |
|
|
|
275 |
|
|
/* Highest source_location "given out". */
|
276 |
|
|
source_location highest_location;
|
277 |
|
|
|
278 |
|
|
/* Start of line of highest source_location "given out". */
|
279 |
|
|
source_location highest_line;
|
280 |
|
|
|
281 |
|
|
/* The maximum column number we can quickly allocate. Higher numbers
|
282 |
|
|
may require allocating a new line_map. */
|
283 |
|
|
unsigned int max_column_hint;
|
284 |
|
|
|
285 |
|
|
/* If non-null, the allocator to use when resizing 'maps'. If null,
|
286 |
|
|
xrealloc is used. */
|
287 |
|
|
line_map_realloc reallocator;
|
288 |
|
|
|
289 |
|
|
/* The allocators' function used to know the actual size it
|
290 |
|
|
allocated, for a certain allocation size requested. */
|
291 |
|
|
line_map_round_alloc_size_func round_alloc_size;
|
292 |
|
|
};
|
293 |
|
|
|
294 |
|
|
/* Returns the pointer to the memory region where information about
|
295 |
|
|
maps are stored in the line table SET. MACRO_MAP_P is a flag
|
296 |
|
|
telling if we want macro or ordinary maps. */
|
297 |
|
|
#define LINEMAPS_MAP_INFO(SET, MACRO_MAP_P) \
|
298 |
|
|
((MACRO_MAP_P) \
|
299 |
|
|
? &((SET)->info_macro) \
|
300 |
|
|
: &((SET)->info_ordinary))
|
301 |
|
|
|
302 |
|
|
/* Returns the pointer to the memory region where maps are stored in
|
303 |
|
|
the line table SET. MAP_KIND shall be TRUE if we are interested in
|
304 |
|
|
macro maps false otherwise. */
|
305 |
|
|
#define LINEMAPS_MAPS(SET, MAP_KIND) \
|
306 |
|
|
(LINEMAPS_MAP_INFO (SET, MAP_KIND))->maps
|
307 |
|
|
|
308 |
|
|
/* Returns the number of allocated maps so far. MAP_KIND shall be TRUE
|
309 |
|
|
if we are interested in macro maps, FALSE otherwise. */
|
310 |
|
|
#define LINEMAPS_ALLOCATED(SET, MAP_KIND) \
|
311 |
|
|
(LINEMAPS_MAP_INFO (SET, MAP_KIND))->allocated
|
312 |
|
|
|
313 |
|
|
/* Returns the number of used maps so far. MAP_KIND shall be TRUE if
|
314 |
|
|
we are interested in macro maps, FALSE otherwise.*/
|
315 |
|
|
#define LINEMAPS_USED(SET, MAP_KIND) \
|
316 |
|
|
(LINEMAPS_MAP_INFO (SET, MAP_KIND))->used
|
317 |
|
|
|
318 |
|
|
/* Returns the index of the last map that was looked up with
|
319 |
|
|
linemap_lookup. MAP_KIND shall be TRUE if we are interested in
|
320 |
|
|
macro maps, FALSE otherwise. */
|
321 |
|
|
#define LINEMAPS_CACHE(SET, MAP_KIND) \
|
322 |
|
|
(LINEMAPS_MAP_INFO (SET, MAP_KIND))->cache
|
323 |
|
|
|
324 |
|
|
/* Return the map at a given index. */
|
325 |
|
|
#define LINEMAPS_MAP_AT(SET, MAP_KIND, INDEX) \
|
326 |
|
|
(&((LINEMAPS_MAPS (SET, MAP_KIND))[(INDEX)]))
|
327 |
|
|
|
328 |
|
|
/* Returns the last map used in the line table SET. MAP_KIND
|
329 |
|
|
shall be TRUE if we are interested in macro maps, FALSE
|
330 |
|
|
otherwise.*/
|
331 |
|
|
#define LINEMAPS_LAST_MAP(SET, MAP_KIND) \
|
332 |
|
|
LINEMAPS_MAP_AT (SET, MAP_KIND, (LINEMAPS_USED (SET, MAP_KIND) - 1))
|
333 |
|
|
|
334 |
|
|
/* Returns the last map that was allocated in the line table SET.
|
335 |
|
|
MAP_KIND shall be TRUE if we are interested in macro maps, FALSE
|
336 |
|
|
otherwise.*/
|
337 |
|
|
#define LINEMAPS_LAST_ALLOCATED_MAP(SET, MAP_KIND) \
|
338 |
|
|
LINEMAPS_MAP_AT (SET, MAP_KIND, LINEMAPS_ALLOCATED (SET, MAP_KIND) - 1)
|
339 |
|
|
|
340 |
|
|
/* Returns a pointer to the memory region where ordinary maps are
|
341 |
|
|
allocated in the line table SET. */
|
342 |
|
|
#define LINEMAPS_ORDINARY_MAPS(SET) \
|
343 |
|
|
LINEMAPS_MAPS (SET, false)
|
344 |
|
|
|
345 |
|
|
/* Returns the INDEXth ordinary map. */
|
346 |
|
|
#define LINEMAPS_ORDINARY_MAP_AT(SET, INDEX) \
|
347 |
|
|
LINEMAPS_MAP_AT (SET, false, INDEX)
|
348 |
|
|
|
349 |
|
|
/* Return the number of ordinary maps allocated in the line table
|
350 |
|
|
SET. */
|
351 |
|
|
#define LINEMAPS_ORDINARY_ALLOCATED(SET) \
|
352 |
|
|
LINEMAPS_ALLOCATED(SET, false)
|
353 |
|
|
|
354 |
|
|
/* Return the number of ordinary maps used in the line table SET. */
|
355 |
|
|
#define LINEMAPS_ORDINARY_USED(SET) \
|
356 |
|
|
LINEMAPS_USED(SET, false)
|
357 |
|
|
|
358 |
|
|
/* Return the index of the last ordinary map that was looked up with
|
359 |
|
|
linemap_lookup. */
|
360 |
|
|
#define LINEMAPS_ORDINARY_CACHE(SET) \
|
361 |
|
|
LINEMAPS_CACHE(SET, false)
|
362 |
|
|
|
363 |
|
|
/* Returns a pointer to the last ordinary map used in the line table
|
364 |
|
|
SET. */
|
365 |
|
|
#define LINEMAPS_LAST_ORDINARY_MAP(SET) \
|
366 |
|
|
LINEMAPS_LAST_MAP(SET, false)
|
367 |
|
|
|
368 |
|
|
/* Returns a pointer to the last ordinary map allocated the line table
|
369 |
|
|
SET. */
|
370 |
|
|
#define LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP(SET) \
|
371 |
|
|
LINEMAPS_LAST_ALLOCATED_MAP(SET, false)
|
372 |
|
|
|
373 |
|
|
/* Returns a pointer to the begining of the region where macro maps
|
374 |
|
|
are allcoated. */
|
375 |
|
|
#define LINEMAPS_MACRO_MAPS(SET) \
|
376 |
|
|
LINEMAPS_MAPS(SET, true)
|
377 |
|
|
|
378 |
|
|
/* Returns the INDEXth macro map. */
|
379 |
|
|
#define LINEMAPS_MACRO_MAP_AT(SET, INDEX) \
|
380 |
|
|
LINEMAPS_MAP_AT (SET, true, INDEX)
|
381 |
|
|
|
382 |
|
|
/* Returns the number of macro maps that were allocated in the line
|
383 |
|
|
table SET. */
|
384 |
|
|
#define LINEMAPS_MACRO_ALLOCATED(SET) \
|
385 |
|
|
LINEMAPS_ALLOCATED(SET, true)
|
386 |
|
|
|
387 |
|
|
/* Returns the number of macro maps used in the line table SET. */
|
388 |
|
|
#define LINEMAPS_MACRO_USED(SET) \
|
389 |
|
|
LINEMAPS_USED(SET, true)
|
390 |
|
|
|
391 |
|
|
/* Returns the index of the last macro map looked up with
|
392 |
|
|
linemap_lookup. */
|
393 |
|
|
#define LINEMAPS_MACRO_CACHE(SET) \
|
394 |
|
|
LINEMAPS_CACHE(SET, true)
|
395 |
|
|
|
396 |
|
|
/* Returns the lowest location [of a token resulting from macro
|
397 |
|
|
expansion] encoded in this line table. */
|
398 |
|
|
#define LINEMAPS_MACRO_LOWEST_LOCATION(SET) \
|
399 |
|
|
(LINEMAPS_MACRO_USED (set) \
|
400 |
|
|
? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set)) \
|
401 |
|
|
: MAX_SOURCE_LOCATION)
|
402 |
|
|
|
403 |
|
|
/* Returns the last macro map used in the line table SET. */
|
404 |
|
|
#define LINEMAPS_LAST_MACRO_MAP(SET) \
|
405 |
|
|
LINEMAPS_LAST_MAP (SET, true)
|
406 |
|
|
|
407 |
|
|
/* Returns the last macro map allocated in the line table SET. */
|
408 |
|
|
#define LINEMAPS_LAST_ALLOCATED_MACRO_MAP(SET) \
|
409 |
|
|
LINEMAPS_LAST_ALLOCATED_MAP (SET, true)
|
410 |
|
|
|
411 |
|
|
/* Initialize a line map set. */
|
412 |
|
|
extern void linemap_init (struct line_maps *);
|
413 |
|
|
|
414 |
|
|
/* Check for and warn about line_maps entered but not exited. */
|
415 |
|
|
|
416 |
|
|
extern void linemap_check_files_exited (struct line_maps *);
|
417 |
|
|
|
418 |
|
|
/* Return a source_location for the start (i.e. column==0) of
|
419 |
|
|
(physical) line TO_LINE in the current source file (as in the
|
420 |
|
|
most recent linemap_add). MAX_COLUMN_HINT is the highest column
|
421 |
|
|
number we expect to use in this line (but it does not change
|
422 |
|
|
the highest_location). */
|
423 |
|
|
|
424 |
|
|
extern source_location linemap_line_start
|
425 |
|
|
(struct line_maps *set, linenum_type to_line, unsigned int max_column_hint);
|
426 |
|
|
|
427 |
|
|
/* Add a mapping of logical source line to physical source file and
|
428 |
|
|
line number. This function creates an "ordinary map", which is a
|
429 |
|
|
map that records locations of tokens that are not part of macro
|
430 |
|
|
replacement-lists present at a macro expansion point.
|
431 |
|
|
|
432 |
|
|
The text pointed to by TO_FILE must have a lifetime
|
433 |
|
|
at least as long as the lifetime of SET. An empty
|
434 |
|
|
TO_FILE means standard input. If reason is LC_LEAVE, and
|
435 |
|
|
TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
|
436 |
|
|
natural values considering the file we are returning to.
|
437 |
|
|
|
438 |
|
|
A call to this function can relocate the previous set of
|
439 |
|
|
maps, so any stored line_map pointers should not be used. */
|
440 |
|
|
extern const struct line_map *linemap_add
|
441 |
|
|
(struct line_maps *, enum lc_reason, unsigned int sysp,
|
442 |
|
|
const char *to_file, linenum_type to_line);
|
443 |
|
|
|
444 |
|
|
/* Given a logical source location, returns the map which the
|
445 |
|
|
corresponding (source file, line, column) triplet can be deduced
|
446 |
|
|
from. Since the set is built chronologically, the logical lines are
|
447 |
|
|
monotonic increasing, and so the list is sorted and we can use a
|
448 |
|
|
binary search. If no line map have been allocated yet, this
|
449 |
|
|
function returns NULL. */
|
450 |
|
|
extern const struct line_map *linemap_lookup
|
451 |
|
|
(struct line_maps *, source_location);
|
452 |
|
|
|
453 |
|
|
/* Returns TRUE if the line table set tracks token locations accross
|
454 |
|
|
macro expansion, FALSE otherwise. */
|
455 |
|
|
bool linemap_tracks_macro_expansion_locs_p (struct line_maps *);
|
456 |
|
|
|
457 |
|
|
/* Return TRUE if MAP encodes locations coming from a macro
|
458 |
|
|
replacement-list at macro expansion point. */
|
459 |
|
|
bool linemap_macro_expansion_map_p (const struct line_map *);
|
460 |
|
|
|
461 |
|
|
/* Return the name of the macro associated to MACRO_MAP. */
|
462 |
|
|
const char* linemap_map_get_macro_name (const struct line_map*);
|
463 |
|
|
|
464 |
|
|
/* Return a positive value if LOCATION is the locus of a token that is
|
465 |
|
|
located in a system header, O otherwise. It returns 1 if LOCATION
|
466 |
|
|
is the locus of a token that is located in a system header, and 2
|
467 |
|
|
if LOCATION is the locus of a token located in a C system header
|
468 |
|
|
that therefore needs to be extern "C" protected in C++.
|
469 |
|
|
|
470 |
|
|
Note that this function returns 1 if LOCATION belongs to a token
|
471 |
|
|
that is part of a macro replacement-list defined in a system
|
472 |
|
|
header, but expanded in a non-system file. */
|
473 |
|
|
int linemap_location_in_system_header_p (struct line_maps *,
|
474 |
|
|
source_location);
|
475 |
|
|
|
476 |
|
|
/* Return TRUE if LOCATION is a source code location of a token coming
|
477 |
|
|
from a macro replacement-list at a macro expansion point, FALSE
|
478 |
|
|
otherwise. */
|
479 |
|
|
bool linemap_location_from_macro_expansion_p (struct line_maps *,
|
480 |
|
|
source_location);
|
481 |
|
|
|
482 |
|
|
/* source_location values from 0 to RESERVED_LOCATION_COUNT-1 will
|
483 |
|
|
be reserved for libcpp user as special values, no token from libcpp
|
484 |
|
|
will contain any of those locations. */
|
485 |
|
|
#define RESERVED_LOCATION_COUNT 2
|
486 |
|
|
|
487 |
|
|
/* Converts a map and a source_location to source line. */
|
488 |
|
|
#define SOURCE_LINE(MAP, LOC) \
|
489 |
|
|
(((((LOC) - linemap_check_ordinary (MAP)->start_location) \
|
490 |
|
|
>> (MAP)->d.ordinary.column_bits) + (MAP)->d.ordinary.to_line))
|
491 |
|
|
|
492 |
|
|
/* Convert a map and source_location to source column number. */
|
493 |
|
|
#define SOURCE_COLUMN(MAP, LOC) \
|
494 |
|
|
((((LOC) - linemap_check_ordinary (MAP)->start_location) \
|
495 |
|
|
& ((1 << (MAP)->d.ordinary.column_bits) - 1)))
|
496 |
|
|
|
497 |
|
|
/* Returns the last source line number within an ordinary map. This
|
498 |
|
|
is the (last) line of the #include, or other directive, that caused
|
499 |
|
|
a map change. */
|
500 |
|
|
#define LAST_SOURCE_LINE(MAP) \
|
501 |
|
|
SOURCE_LINE (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
|
502 |
|
|
|
503 |
|
|
/* Return the last column number within an ordinary map. */
|
504 |
|
|
#define LAST_SOURCE_COLUMN(MAP) \
|
505 |
|
|
SOURCE_COLUMN (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
|
506 |
|
|
|
507 |
|
|
/* Return the location of the last source line within an ordinary
|
508 |
|
|
map. */
|
509 |
|
|
#define LAST_SOURCE_LINE_LOCATION(MAP) \
|
510 |
|
|
((((linemap_check_ordinary (MAP)[1].start_location - 1 \
|
511 |
|
|
- (MAP)->start_location) \
|
512 |
|
|
& ~((1 << (MAP)->d.ordinary.column_bits) - 1)) \
|
513 |
|
|
+ (MAP)->start_location))
|
514 |
|
|
|
515 |
|
|
/* Returns the map a given map was included from, or NULL if the map
|
516 |
|
|
belongs to the main file, i.e, a file that wasn't included by
|
517 |
|
|
another one. */
|
518 |
|
|
#define INCLUDED_FROM(SET, MAP) \
|
519 |
|
|
((linemap_check_ordinary (MAP)->d.ordinary.included_from == -1) \
|
520 |
|
|
? NULL \
|
521 |
|
|
: (&LINEMAPS_ORDINARY_MAPS (SET)[(MAP)->d.ordinary.included_from]))
|
522 |
|
|
|
523 |
|
|
/* Nonzero if the map is at the bottom of the include stack. */
|
524 |
|
|
#define MAIN_FILE_P(MAP) \
|
525 |
|
|
((linemap_check_ordinary (MAP)->d.ordinary.included_from < 0))
|
526 |
|
|
|
527 |
|
|
#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
|
528 |
|
|
|
529 |
|
|
/* Assertion macro to be used in line-map code. */
|
530 |
|
|
#define linemap_assert(EXPR) \
|
531 |
|
|
do { \
|
532 |
|
|
if (! (EXPR)) \
|
533 |
|
|
abort (); \
|
534 |
|
|
} while (0)
|
535 |
|
|
|
536 |
|
|
/* Assert that MAP encodes locations of tokens that are not part of
|
537 |
|
|
the replacement-list of a macro expansion. */
|
538 |
|
|
#define linemap_check_ordinary(LINE_MAP) __extension__ \
|
539 |
|
|
({linemap_assert (!linemap_macro_expansion_map_p (LINE_MAP)); \
|
540 |
|
|
(LINE_MAP);})
|
541 |
|
|
#else
|
542 |
|
|
#define linemap_assert(EXPR)
|
543 |
|
|
#define linemap_check_ordinary(LINE_MAP) (LINE_MAP)
|
544 |
|
|
#endif
|
545 |
|
|
|
546 |
|
|
/* Encode and return a source_location from a column number. The
|
547 |
|
|
source line considered is the last source line used to call
|
548 |
|
|
linemap_line_start, i.e, the last source line which a location was
|
549 |
|
|
encoded from. */
|
550 |
|
|
extern source_location
|
551 |
|
|
linemap_position_for_column (struct line_maps *, unsigned int);
|
552 |
|
|
|
553 |
|
|
/* Encode and return a source location from a given line and
|
554 |
|
|
column. */
|
555 |
|
|
source_location linemap_position_for_line_and_column (struct line_map *,
|
556 |
|
|
linenum_type,
|
557 |
|
|
unsigned int);
|
558 |
|
|
/* Return the file this map is for. */
|
559 |
|
|
#define LINEMAP_FILE(MAP) \
|
560 |
|
|
(linemap_check_ordinary (MAP)->d.ordinary.to_file)
|
561 |
|
|
|
562 |
|
|
/* Return the line number this map started encoding location from. */
|
563 |
|
|
#define LINEMAP_LINE(MAP) \
|
564 |
|
|
(linemap_check_ordinary (MAP)->d.ordinary.to_line)
|
565 |
|
|
|
566 |
|
|
/* Return a positive value if map encodes locations from a system
|
567 |
|
|
header, 0 otherwise. Returns 1 if MAP encodes locations in a
|
568 |
|
|
system header and 2 if it encodes locations in a C system header
|
569 |
|
|
that therefore needs to be extern "C" protected in C++. */
|
570 |
|
|
#define LINEMAP_SYSP(MAP) \
|
571 |
|
|
(linemap_check_ordinary (MAP)->d.ordinary.sysp)
|
572 |
|
|
|
573 |
|
|
/* Return a positive value if PRE denotes the location of a token that
|
574 |
|
|
comes before the token of POST, 0 if PRE denotes the location of
|
575 |
|
|
the same token as the token for POST, and a negative value
|
576 |
|
|
otherwise. */
|
577 |
|
|
int linemap_compare_locations (struct line_maps *set,
|
578 |
|
|
source_location pre,
|
579 |
|
|
source_location post);
|
580 |
|
|
|
581 |
|
|
/* Return TRUE if LOC_A denotes the location a token that comes
|
582 |
|
|
topogically before the token denoted by location LOC_B, or if they
|
583 |
|
|
are equal. */
|
584 |
|
|
#define linemap_location_before_p(SET, LOC_A, LOC_B) \
|
585 |
|
|
(linemap_compare_locations ((SET), (LOC_A), (LOC_B)) >= 0)
|
586 |
|
|
|
587 |
|
|
typedef struct
|
588 |
|
|
{
|
589 |
|
|
/* The name of the source file involved. */
|
590 |
|
|
const char *file;
|
591 |
|
|
|
592 |
|
|
/* The line-location in the source file. */
|
593 |
|
|
int line;
|
594 |
|
|
|
595 |
|
|
int column;
|
596 |
|
|
|
597 |
|
|
/* In a system header?. */
|
598 |
|
|
bool sysp;
|
599 |
|
|
} expanded_location;
|
600 |
|
|
|
601 |
|
|
/* This is enum is used by the function linemap_resolve_location
|
602 |
|
|
below. The meaning of the values is explained in the comment of
|
603 |
|
|
that function. */
|
604 |
|
|
enum location_resolution_kind
|
605 |
|
|
{
|
606 |
|
|
LRK_MACRO_EXPANSION_POINT,
|
607 |
|
|
LRK_SPELLING_LOCATION,
|
608 |
|
|
LRK_MACRO_DEFINITION_LOCATION
|
609 |
|
|
};
|
610 |
|
|
|
611 |
|
|
/* Resolve a virtual location into either a spelling location, an
|
612 |
|
|
expansion point location or a token argument replacement point
|
613 |
|
|
location. Return the map that encodes the virtual location as well
|
614 |
|
|
as the resolved location.
|
615 |
|
|
|
616 |
|
|
If LOC is *NOT* the location of a token resulting from the
|
617 |
|
|
expansion of a macro, then the parameter LRK (which stands for
|
618 |
|
|
Location Resolution Kind) is ignored and the resulting location
|
619 |
|
|
just equals the one given in argument.
|
620 |
|
|
|
621 |
|
|
Now if LOC *IS* the location of a token resulting from the
|
622 |
|
|
expansion of a macro, this is what happens.
|
623 |
|
|
|
624 |
|
|
* If LRK is set to LRK_MACRO_EXPANSION_POINT
|
625 |
|
|
-------------------------------
|
626 |
|
|
|
627 |
|
|
The virtual location is resolved to the first macro expansion point
|
628 |
|
|
that led to this macro expansion.
|
629 |
|
|
|
630 |
|
|
* If LRK is set to LRK_SPELLING_LOCATION
|
631 |
|
|
-------------------------------------
|
632 |
|
|
|
633 |
|
|
The virtual location is resolved to the locus where the token has
|
634 |
|
|
been spelled in the source. This can follow through all the macro
|
635 |
|
|
expansions that led to the token.
|
636 |
|
|
|
637 |
|
|
* If LRK is set to LRK_MACRO_DEFINITION_LOCATION
|
638 |
|
|
--------------------------------------
|
639 |
|
|
|
640 |
|
|
The virtual location is resolved to the locus of the token in the
|
641 |
|
|
context of the macro definition.
|
642 |
|
|
|
643 |
|
|
If LOC is the locus of a token that is an argument of a
|
644 |
|
|
function-like macro [replacing a parameter in the replacement list
|
645 |
|
|
of the macro] the virtual location is resolved to the locus of the
|
646 |
|
|
parameter that is replaced, in the context of the definition of the
|
647 |
|
|
macro.
|
648 |
|
|
|
649 |
|
|
If LOC is the locus of a token that is not an argument of a
|
650 |
|
|
function-like macro, then the function behaves as if LRK was set to
|
651 |
|
|
LRK_SPELLING_LOCATION.
|
652 |
|
|
|
653 |
|
|
If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the
|
654 |
|
|
returned location. Note that if the resturned location wasn't originally
|
655 |
|
|
encoded by a map, the *MAP is set to NULL. This can happen if LOC
|
656 |
|
|
resolves to a location reserved for the client code, like
|
657 |
|
|
UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
|
658 |
|
|
|
659 |
|
|
source_location linemap_resolve_location (struct line_maps *,
|
660 |
|
|
source_location loc,
|
661 |
|
|
enum location_resolution_kind lrk,
|
662 |
|
|
const struct line_map **loc_map);
|
663 |
|
|
|
664 |
|
|
/* Suppose that LOC is the virtual location of a token coming from the
|
665 |
|
|
expansion of a macro M. This function then steps up to get the
|
666 |
|
|
location L of the point where M got expanded. If L is a spelling
|
667 |
|
|
location inside a macro expansion M', then this function returns
|
668 |
|
|
the point where M' was expanded. LOC_MAP is an output parameter.
|
669 |
|
|
When non-NULL, *LOC_MAP is set the the map of the returned
|
670 |
|
|
location. */
|
671 |
|
|
source_location linemap_unwind_toward_expansion (struct line_maps *,
|
672 |
|
|
source_location loc,
|
673 |
|
|
const struct line_map **loc_map);
|
674 |
|
|
|
675 |
|
|
/* Expand source code location LOC and return a user readable source
|
676 |
|
|
code location. LOC must be a spelling (non-virtual) location. If
|
677 |
|
|
it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
|
678 |
|
|
location is returned. */
|
679 |
|
|
expanded_location linemap_expand_location (struct line_maps *,
|
680 |
|
|
const struct line_map *,
|
681 |
|
|
source_location loc);
|
682 |
|
|
|
683 |
|
|
/* Statistics about maps allocation and usage as returned by
|
684 |
|
|
linemap_get_statistics. */
|
685 |
|
|
struct linemap_stats
|
686 |
|
|
{
|
687 |
|
|
long num_ordinary_maps_allocated;
|
688 |
|
|
long num_ordinary_maps_used;
|
689 |
|
|
long ordinary_maps_allocated_size;
|
690 |
|
|
long ordinary_maps_used_size;
|
691 |
|
|
long num_expanded_macros;
|
692 |
|
|
long num_macro_tokens;
|
693 |
|
|
long num_macro_maps_used;
|
694 |
|
|
long macro_maps_allocated_size;
|
695 |
|
|
long macro_maps_used_size;
|
696 |
|
|
long macro_maps_locations_size;
|
697 |
|
|
long duplicated_macro_maps_locations_size;
|
698 |
|
|
};
|
699 |
|
|
|
700 |
|
|
/* Compute and return statistics about the memory consumption of some
|
701 |
|
|
parts of the line table SET. */
|
702 |
|
|
void linemap_get_statistics (struct line_maps *, struct linemap_stats *);
|
703 |
|
|
|
704 |
|
|
/* Dump debugging information about source location LOC into the file
|
705 |
|
|
stream STREAM. SET is the line map set LOC comes from. */
|
706 |
|
|
void linemap_dump_location (struct line_maps *, source_location, FILE *);
|
707 |
|
|
|
708 |
|
|
/* Dump line map at index IX in line table SET to STREAM. If STREAM
|
709 |
|
|
is NULL, use stderr. IS_MACRO is true if the caller wants to
|
710 |
|
|
dump a macro map, false otherwise. */
|
711 |
|
|
void linemap_dump (FILE *, struct line_maps *, unsigned, bool);
|
712 |
|
|
|
713 |
|
|
/* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
|
714 |
|
|
NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
|
715 |
|
|
specifies how many macro maps to dump. */
|
716 |
|
|
void line_table_dump (FILE *, struct line_maps *, unsigned int, unsigned int);
|
717 |
|
|
|
718 |
|
|
#endif /* !LIBCPP_LINE_MAP_H */
|