OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libcpp/] [include/] [line-map.h] - Blame information for rev 730

Details | Compare with Previous | View Log

Line No. Rev Author Line
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  */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.