| /* Map (unsigned int) keys to (source file, line, column) triples. |
| Copyright (C) 2001-2021 Free Software Foundation, Inc. |
| |
| This program is free software; you can redistribute it and/or modify it |
| under the terms of the GNU General Public License as published by the |
| Free Software Foundation; either version 3, or (at your option) any |
| later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. |
| |
| In other words, you are welcome to use, share and improve this program. |
| You are forbidden to forbid anyone else to use, share and improve |
| what you give them. Help stamp out software-hoarding! */ |
| |
| #ifndef LIBCPP_LINE_MAP_H |
| #define LIBCPP_LINE_MAP_H |
| |
| #ifndef GTY |
| #define GTY(x) /* nothing */ |
| #endif |
| |
| /* Both gcc and emacs number source *lines* starting at 1, but |
| they have differing conventions for *columns*. |
| |
| GCC uses a 1-based convention for source columns, |
| whereas Emacs's M-x column-number-mode uses a 0-based convention. |
| |
| For example, an error in the initial, left-hand |
| column of source line 3 is reported by GCC as: |
| |
| some-file.c:3:1: error: ...etc... |
| |
| On navigating to the location of that error in Emacs |
| (e.g. via "next-error"), |
| the locus is reported in the Mode Line |
| (assuming M-x column-number-mode) as: |
| |
| some-file.c 10% (3, 0) |
| |
| i.e. "3:1:" in GCC corresponds to "(3, 0)" in Emacs. */ |
| |
| /* The type of line numbers. */ |
| typedef unsigned int linenum_type; |
| |
| /* A type for doing arithmetic on line numbers. */ |
| typedef long long linenum_arith_t; |
| |
| /* A function for for use by qsort for comparing line numbers. */ |
| |
| inline int compare (linenum_type lhs, linenum_type rhs) |
| { |
| /* Avoid truncation issues by using linenum_arith_t for the comparison, |
| and only consider the sign of the result. */ |
| linenum_arith_t diff = (linenum_arith_t)lhs - (linenum_arith_t)rhs; |
| if (diff) |
| return diff > 0 ? 1 : -1; |
| return 0; |
| } |
| |
| /* Reason for creating a new line map with linemap_add. */ |
| enum lc_reason |
| { |
| LC_ENTER = 0, /* Begin #include. */ |
| LC_LEAVE, /* Return to including file. */ |
| LC_RENAME, /* Other reason for name change. */ |
| LC_RENAME_VERBATIM, /* Likewise, but "" != stdin. */ |
| LC_ENTER_MACRO, /* Begin macro expansion. */ |
| LC_MODULE, /* A (C++) Module. */ |
| /* FIXME: add support for stringize and paste. */ |
| LC_HWM /* High Water Mark. */ |
| }; |
| |
| /* The typedef "location_t" is a key within the location database, |
| identifying a source location or macro expansion, along with range |
| information, and (optionally) a pointer for use by gcc. |
| |
| This key only has meaning in relation to a line_maps instance. Within |
| gcc there is a single line_maps instance: "line_table", declared in |
| gcc/input.h and defined in gcc/input.c. |
| |
| The values of the keys are intended to be internal to libcpp, |
| but for ease-of-understanding the implementation, they are currently |
| assigned as follows: |
| |
| Actual | Value | Meaning |
| -----------+-------------------------------+------------------------------- |
| 0x00000000 | UNKNOWN_LOCATION (gcc/input.h)| Unknown/invalid location. |
| -----------+-------------------------------+------------------------------- |
| 0x00000001 | BUILTINS_LOCATION | The location for declarations |
| | (gcc/input.h) | in "<built-in>" |
| -----------+-------------------------------+------------------------------- |
| 0x00000002 | RESERVED_LOCATION_COUNT | The first location to be |
| | (also | handed out, and the |
| | ordmap[0]->start_location) | first line in ordmap 0 |
| -----------+-------------------------------+------------------------------- |
| | ordmap[1]->start_location | First line in ordmap 1 |
| | ordmap[1]->start_location+32 | First column in that line |
| | (assuming range_bits == 5) | |
| | ordmap[1]->start_location+64 | 2nd column in that line |
| | ordmap[1]->start_location+4096| Second line in ordmap 1 |
| | (assuming column_bits == 12) |
| | |
| | Subsequent lines are offset by (1 << column_bits), |
| | e.g. 4096 for 12 bits, with a column value of 0 representing |
| | "the whole line". |
| | |
| | Within a line, the low "range_bits" (typically 5) are used for |
| | storing short ranges, so that there's an offset of |
| | (1 << range_bits) between individual columns within a line, |
| | typically 32. |
| | The low range_bits store the offset of the end point from the |
| | start point, and the start point is found by masking away |
| | the range bits. |
| | |
| | For example: |
| | ordmap[1]->start_location+64 "2nd column in that line" |
| | above means a caret at that location, with a range |
| | starting and finishing at the same place (the range bits |
| | are 0), a range of length 1. |
| | |
| | By contrast: |
| | ordmap[1]->start_location+68 |
| | has range bits 0x4, meaning a caret with a range starting at |
| | that location, but with endpoint 4 columns further on: a range |
| | of length 5. |
| | |
| | Ranges that have caret != start, or have an endpoint too |
| | far away to fit in range_bits are instead stored as ad-hoc |
| | locations. Hence for range_bits == 5 we can compactly store |
| | tokens of length <= 32 without needing to use the ad-hoc |
| | table. |
| | |
| | This packing scheme means we effectively have |
| | (column_bits - range_bits) |
| | of bits for the columns, typically (12 - 5) = 7, for 128 |
| | columns; longer line widths are accomodated by starting a |
| | new ordmap with a higher column_bits. |
| | |
| | ordmap[2]->start_location-1 | Final location in ordmap 1 |
| -----------+-------------------------------+------------------------------- |
| | ordmap[2]->start_location | First line in ordmap 2 |
| | ordmap[3]->start_location-1 | Final location in ordmap 2 |
| -----------+-------------------------------+------------------------------- |
| | | (etc) |
| -----------+-------------------------------+------------------------------- |
| | ordmap[n-1]->start_location | First line in final ord map |
| | | (etc) |
| | set->highest_location - 1 | Final location in that ordmap |
| -----------+-------------------------------+------------------------------- |
| | set->highest_location | Location of the where the next |
| | | ordinary linemap would start |
| -----------+-------------------------------+------------------------------- |
| | | |
| | VVVVVVVVVVVVVVVVVVVVVVVVVVV |
| | Ordinary maps grow this way |
| | |
| | (unallocated integers) |
| | |
| 0x60000000 | LINE_MAP_MAX_LOCATION_WITH_COLS |
| | Beyond this point, ordinary linemaps have 0 bits per column: |
| | each increment of the value corresponds to a new source line. |
| | |
| 0x70000000 | LINE_MAP_MAX_LOCATION |
| | Beyond the point, we give up on ordinary maps; attempts to |
| | create locations in them lead to UNKNOWN_LOCATION (0). |
| | |
| | (unallocated integers) |
| | |
| | Macro maps grow this way |
| | ^^^^^^^^^^^^^^^^^^^^^^^^ |
| | | |
| -----------+-------------------------------+------------------------------- |
| | LINEMAPS_MACRO_LOWEST_LOCATION| Locations within macro maps |
| | macromap[m-1]->start_location | Start of last macro map |
| | | |
| -----------+-------------------------------+------------------------------- |
| | macromap[m-2]->start_location | Start of penultimate macro map |
| -----------+-------------------------------+------------------------------- |
| | macromap[1]->start_location | Start of macro map 1 |
| -----------+-------------------------------+------------------------------- |
| | macromap[0]->start_location | Start of macro map 0 |
| 0x7fffffff | MAX_LOCATION_T | Also used as a mask for |
| | | accessing the ad-hoc data table |
| -----------+-------------------------------+------------------------------- |
| 0x80000000 | Start of ad-hoc values; the lower 31 bits are used as an index |
| ... | into the line_table->location_adhoc_data_map.data array. |
| 0xffffffff | UINT_MAX | |
| -----------+-------------------------------+------------------------------- |
| |
| Examples of location encoding. |
| |
| Packed ranges |
| ============= |
| |
| Consider encoding the location of a token "foo", seen underlined here |
| on line 523, within an ordinary line_map that starts at line 500: |
| |
| 11111111112 |
| 12345678901234567890 |
| 522 |
| 523 return foo + bar; |
| ^~~ |
| 524 |
| |
| The location's caret and start are both at line 523, column 11; the |
| location's finish is on the same line, at column 13 (an offset of 2 |
| columns, for length 3). |
| |
| Line 523 is offset 23 from the starting line of the ordinary line_map. |
| |
| caret == start, and the offset of the finish fits within 5 bits, so |
| this can be stored as a packed range. |
| |
| This is encoded as: |
| ordmap->start |
| + (line_offset << ordmap->m_column_and_range_bits) |
| + (column << ordmap->m_range_bits) |
| + (range_offset); |
| i.e. (for line offset 23, column 11, range offset 2): |
| ordmap->start |
| + (23 << 12) |
| + (11 << 5) |
| + 2; |
| i.e.: |
| ordmap->start + 0x17162 |
| assuming that the line_map uses the default of 7 bits for columns and |
| 5 bits for packed range (giving 12 bits for m_column_and_range_bits). |
| |
| |
| "Pure" locations |
| ================ |
| |
| These are a special case of the above, where |
| caret == start == finish |
| They are stored as packed ranges with offset == 0. |
| For example, the location of the "f" of "foo" could be stored |
| as above, but with range offset 0, giving: |
| ordmap->start |
| + (23 << 12) |
| + (11 << 5) |
| + 0; |
| i.e.: |
| ordmap->start + 0x17160 |
| |
| |
| Unoptimized ranges |
| ================== |
| |
| Consider encoding the location of the binary expression |
| below: |
| |
| 11111111112 |
| 12345678901234567890 |
| 522 |
| 523 return foo + bar; |
| ~~~~^~~~~ |
| 524 |
| |
| The location's caret is at the "+", line 523 column 15, but starts |
| earlier, at the "f" of "foo" at column 11. The finish is at the "r" |
| of "bar" at column 19. |
| |
| This can't be stored as a packed range since start != caret. |
| Hence it is stored as an ad-hoc location e.g. 0x80000003. |
| |
| Stripping off the top bit gives us an index into the ad-hoc |
| lookaside table: |
| |
| line_table->location_adhoc_data_map.data[0x3] |
| |
| from which the caret, start and finish can be looked up, |
| encoded as "pure" locations: |
| |
| start == ordmap->start + (23 << 12) + (11 << 5) |
| == ordmap->start + 0x17160 (as above; the "f" of "foo") |
| |
| caret == ordmap->start + (23 << 12) + (15 << 5) |
| == ordmap->start + 0x171e0 |
| |
| finish == ordmap->start + (23 << 12) + (19 << 5) |
| == ordmap->start + 0x17260 |
| |
| To further see how location_t works in practice, see the |
| worked example in libcpp/location-example.txt. */ |
| typedef unsigned int location_t; |
| |
| /* Do not track column numbers higher than this one. As a result, the |
| range of column_bits is [12, 18] (or 0 if column numbers are |
| disabled). */ |
| const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12); |
| |
| /* Do not pack ranges if locations get higher than this. |
| If you change this, update: |
| gcc.dg/plugin/location-overflow-test-*.c. */ |
| const location_t LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000; |
| |
| /* Do not track column numbers if locations get higher than this. |
| If you change this, update: |
| gcc.dg/plugin/location-overflow-test-*.c. */ |
| const location_t LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000; |
| |
| /* Highest possible source location encoded within an ordinary map. */ |
| const location_t LINE_MAP_MAX_LOCATION = 0x70000000; |
| |
| /* A range of source locations. |
| |
| Ranges are closed: |
| m_start is the first location within the range, |
| m_finish is the last location within the range. |
| |
| We may need a more compact way to store these, but for now, |
| let's do it the simple way, as a pair. */ |
| struct GTY(()) source_range |
| { |
| location_t m_start; |
| location_t m_finish; |
| |
| /* We avoid using constructors, since various structs that |
| don't yet have constructors will embed instances of |
| source_range. */ |
| |
| /* Make a source_range from a location_t. */ |
| static source_range from_location (location_t loc) |
| { |
| source_range result; |
| result.m_start = loc; |
| result.m_finish = loc; |
| return result; |
| } |
| |
| /* Make a source_range from a pair of location_t. */ |
| static source_range from_locations (location_t start, |
| location_t finish) |
| { |
| source_range result; |
| result.m_start = start; |
| result.m_finish = finish; |
| return result; |
| } |
| }; |
| |
| /* Memory allocation function typedef. Works like xrealloc. */ |
| typedef void *(*line_map_realloc) (void *, size_t); |
| |
| /* Memory allocator function that returns the actual allocated size, |
| for a given requested allocation. */ |
| typedef size_t (*line_map_round_alloc_size_func) (size_t); |
| |
| /* A line_map encodes a sequence of locations. |
| There are two kinds of maps. Ordinary maps and macro expansion |
| maps, a.k.a macro maps. |
| |
| A macro map encodes source locations of tokens that are part of a |
| macro replacement-list, at a macro expansion point. E.g, in: |
| |
| #define PLUS(A,B) A + B |
| |
| No macro map is going to be created there, because we are not at a |
| macro expansion point. We are at a macro /definition/ point. So the |
| locations of the tokens of the macro replacement-list (i.e, A + B) |
| will be locations in an ordinary map, not a macro map. |
| |
| On the other hand, if we later do: |
| |
| int a = PLUS (1,2); |
| |
| The invocation of PLUS here is a macro expansion. So we are at a |
| macro expansion point. The preprocessor expands PLUS (1,2) and |
| replaces it with the tokens of its replacement-list: 1 + 2. A macro |
| map is going to be created to hold (or rather to map, haha ...) the |
| locations of the tokens 1, + and 2. The macro map also records the |
| location of the expansion point of PLUS. That location is mapped in |
| the map that is active right before the location of the invocation |
| of PLUS. */ |
| |
| /* This contains GTY mark-up to support precompiled headers. |
| line_map is an abstract class, only derived objects exist. */ |
| struct GTY((tag ("0"), desc ("MAP_ORDINARY_P (&%h) ? 1 : 2"))) line_map { |
| location_t start_location; |
| |
| /* Size and alignment is (usually) 4 bytes. */ |
| }; |
| |
| /* An ordinary line map encodes physical source locations. Those |
| physical source locations are called "spelling locations". |
| |
| Physical source file TO_FILE at line TO_LINE at column 0 is represented |
| by the logical START_LOCATION. TO_LINE+L at column C is represented by |
| START_LOCATION+(L*(1<<m_column_and_range_bits))+(C*1<<m_range_bits), as |
| long as C<(1<<effective range bits), and the result_location is less than |
| the next line_map's start_location. |
| (The top line is line 1 and the leftmost column is column 1; line/column 0 |
| means "entire file/line" or "unknown line/column" or "not applicable".) |
| |
| The highest possible source location is MAX_LOCATION_T. */ |
| struct GTY((tag ("1"))) line_map_ordinary : public line_map { |
| /* Base class is 4 bytes. */ |
| |
| /* 4 bytes of integers, each 1 byte for easy extraction/insertion. */ |
| |
| /* The reason for creation of this line map. */ |
| ENUM_BITFIELD (lc_reason) reason : 8; |
| |
| /* SYSP is one for a system header, two for a C system header file |
| that therefore needs to be extern "C" protected in C++, and zero |
| otherwise. This field isn't really needed now that it's in |
| cpp_buffer. */ |
| unsigned char sysp; |
| |
| /* Number of the low-order location_t bits used for column numbers |
| and ranges. */ |
| unsigned int m_column_and_range_bits : 8; |
| |
| /* Number of the low-order "column" bits used for storing short ranges |
| inline, rather than in the ad-hoc table. |
| MSB LSB |
| 31 0 |
| +-------------------------+-------------------------------------------+ |
| | |<---map->column_and_range_bits (e.g. 12)-->| |
| +-------------------------+-----------------------+-------------------+ |
| | | column_and_range_bits | map->range_bits | |
| | | - range_bits | | |
| +-------------------------+-----------------------+-------------------+ |
| | row bits | effective column bits | short range bits | |
| | | (e.g. 7) | (e.g. 5) | |
| +-------------------------+-----------------------+-------------------+ */ |
| unsigned int m_range_bits : 8; |
| |
| /* Pointer alignment boundary on both 32 and 64-bit systems. */ |
| |
| const char *to_file; |
| linenum_type to_line; |
| |
| /* Location from whence this line map was included. For regular |
| #includes, this location will be the last location of a map. For |
| outermost file, this is 0. For modules it could be anywhere |
| within a map. */ |
| location_t included_from; |
| |
| /* Size is 20 or 24 bytes, no padding */ |
| }; |
| |
| /* This is the highest possible source location encoded within an |
| ordinary or macro map. */ |
| const location_t MAX_LOCATION_T = 0x7FFFFFFF; |
| |
| struct cpp_hashnode; |
| |
| /* A macro line map encodes location of tokens coming from a macro |
| expansion. |
| |
| The offset from START_LOCATION is used to index into |
| MACRO_LOCATIONS; this holds the original location of the token. */ |
| struct GTY((tag ("2"))) line_map_macro : public line_map { |
| /* Base is 4 bytes. */ |
| |
| /* The number of tokens inside the replacement-list of MACRO. */ |
| unsigned int n_tokens; |
| |
| /* Pointer alignment boundary. */ |
| |
| /* The cpp macro whose expansion gave birth to this macro map. */ |
| struct cpp_hashnode * |
| GTY ((nested_ptr (union tree_node, |
| "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL", |
| "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"))) |
| macro; |
| |
| /* This array of location is actually an array of pairs of |
| locations. The elements inside it thus look like: |
| |
| x0,y0, x1,y1, x2,y2, ...., xn,yn. |
| |
| where n == n_tokens; |
| |
| Remember that these xI,yI are collected when libcpp is about to |
| expand a given macro. |
| |
| yI is the location in the macro definition, either of the token |
| itself or of a macro parameter that it replaces. |
| |
| Imagine this: |
| |
| #define PLUS(A, B) A + B <--- #1 |
| |
| int a = PLUS (1,2); <--- #2 |
| |
| There is a macro map for the expansion of PLUS in #2. PLUS is |
| expanded into its expansion-list. The expansion-list is the |
| replacement-list of PLUS where the macro parameters are replaced |
| with their arguments. So the replacement-list of PLUS is made of |
| the tokens: |
| |
| A, +, B |
| |
| and the expansion-list is made of the tokens: |
| |
| 1, +, 2 |
| |
| Let's consider the case of token "+". Its y1 [yI for I == 1] is |
| its spelling location in #1. |
| |
| y0 (thus for token "1") is the spelling location of A in #1. |
| |
| And y2 (of token "2") is the spelling location of B in #1. |
| |
| When the token is /not/ an argument for a macro, xI is the same |
| location as yI. Otherwise, xI is the location of the token |
| outside this macro expansion. If this macro was expanded from |
| another macro expansion, xI is a virtual location representing |
| the token in that macro expansion; otherwise, it is the spelling |
| location of the token. |
| |
| Note that a virtual location is a location returned by |
| linemap_add_macro_token. It encodes the relevant locations (x,y |
| pairs) of that token across the macro expansions from which it |
| (the token) might come from. |
| |
| In the example above x1 (for token "+") is going to be the same |
| as y1. x0 is the spelling location for the argument token "1", |
| and x2 is the spelling location for the argument token "2". */ |
| location_t * GTY((atomic)) macro_locations; |
| |
| /* This is the location of the expansion point of the current macro |
| map. It's the location of the macro name. That location is held |
| by the map that was current right before the current one. It |
| could have been either a macro or an ordinary map, depending on |
| if we are in a nested expansion context not. */ |
| location_t expansion; |
| |
| /* Size is 20 or 32 (4 bytes padding on 64-bit). */ |
| }; |
| |
| #if CHECKING_P && (GCC_VERSION >= 2007) |
| |
| /* Assertion macro to be used in line-map code. */ |
| #define linemap_assert(EXPR) \ |
| do { \ |
| if (! (EXPR)) \ |
| abort (); \ |
| } while (0) |
| |
| /* Assert that becomes a conditional expression when checking is disabled at |
| compilation time. Use this for conditions that should not happen but if |
| they happen, it is better to handle them gracefully rather than crash |
| randomly later. |
| Usage: |
| |
| if (linemap_assert_fails(EXPR)) handle_error(); */ |
| #define linemap_assert_fails(EXPR) __extension__ \ |
| ({linemap_assert (EXPR); false;}) |
| |
| #else |
| /* Include EXPR, so that unused variable warnings do not occur. */ |
| #define linemap_assert(EXPR) ((void)(0 && (EXPR))) |
| #define linemap_assert_fails(EXPR) (! (EXPR)) |
| #endif |
| |
| /* Get whether location LOC is an ordinary location. */ |
| |
| inline bool |
| IS_ORDINARY_LOC (location_t loc) |
| { |
| return loc < LINE_MAP_MAX_LOCATION; |
| } |
| |
| /* Get whether location LOC is an ad-hoc location. */ |
| |
| inline bool |
| IS_ADHOC_LOC (location_t loc) |
| { |
| return loc > MAX_LOCATION_T; |
| } |
| |
| /* Categorize line map kinds. */ |
| |
| inline bool |
| MAP_ORDINARY_P (const line_map *map) |
| { |
| return IS_ORDINARY_LOC (map->start_location); |
| } |
| |
| /* Return TRUE if MAP encodes locations coming from a macro |
| replacement-list at macro expansion point. */ |
| bool |
| linemap_macro_expansion_map_p (const line_map *); |
| |
| /* Assert that MAP encodes locations of tokens that are not part of |
| the replacement-list of a macro expansion, downcasting from |
| line_map * to line_map_ordinary *. */ |
| |
| inline line_map_ordinary * |
| linemap_check_ordinary (line_map *map) |
| { |
| linemap_assert (MAP_ORDINARY_P (map)); |
| return (line_map_ordinary *)map; |
| } |
| |
| /* Assert that MAP encodes locations of tokens that are not part of |
| the replacement-list of a macro expansion, downcasting from |
| const line_map * to const line_map_ordinary *. */ |
| |
| inline const line_map_ordinary * |
| linemap_check_ordinary (const line_map *map) |
| { |
| linemap_assert (MAP_ORDINARY_P (map)); |
| return (const line_map_ordinary *)map; |
| } |
| |
| /* Assert that MAP is a macro expansion and downcast to the appropriate |
| subclass. */ |
| |
| inline line_map_macro *linemap_check_macro (line_map *map) |
| { |
| linemap_assert (!MAP_ORDINARY_P (map)); |
| return (line_map_macro *)map; |
| } |
| |
| /* Assert that MAP is a macro expansion and downcast to the appropriate |
| subclass. */ |
| |
| inline const line_map_macro * |
| linemap_check_macro (const line_map *map) |
| { |
| linemap_assert (!MAP_ORDINARY_P (map)); |
| return (const line_map_macro *)map; |
| } |
| |
| /* Read the start location of MAP. */ |
| |
| inline location_t |
| MAP_START_LOCATION (const line_map *map) |
| { |
| return map->start_location; |
| } |
| |
| /* Get the starting line number of ordinary map MAP. */ |
| |
| inline linenum_type |
| ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map) |
| { |
| return ord_map->to_line; |
| } |
| |
| /* Return a positive value if map encodes locations from a system |
| header, 0 otherwise. Returns 1 if ordinary map MAP encodes locations |
| in a system header and 2 if it encodes locations in a C system header |
| that therefore needs to be extern "C" protected in C++. */ |
| |
| inline unsigned char |
| ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map) |
| { |
| return ord_map->sysp; |
| } |
| |
| /* TRUE if this line map is for a module (not a source file). */ |
| |
| inline bool |
| MAP_MODULE_P (const line_map *map) |
| { |
| return (MAP_ORDINARY_P (map) |
| && linemap_check_ordinary (map)->reason == LC_MODULE); |
| } |
| |
| /* Get the filename of ordinary map MAP. */ |
| |
| inline const char * |
| ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map) |
| { |
| return ord_map->to_file; |
| } |
| |
| /* Get the cpp macro whose expansion gave birth to macro map MAP. */ |
| |
| inline cpp_hashnode * |
| MACRO_MAP_MACRO (const line_map_macro *macro_map) |
| { |
| return macro_map->macro; |
| } |
| |
| /* Get the number of tokens inside the replacement-list of the macro |
| that led to macro map MAP. */ |
| |
| inline unsigned int |
| MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map) |
| { |
| return macro_map->n_tokens; |
| } |
| |
| /* Get the array of pairs of locations within macro map MAP. |
| See the declaration of line_map_macro for more information. */ |
| |
| inline location_t * |
| MACRO_MAP_LOCATIONS (const line_map_macro *macro_map) |
| { |
| return macro_map->macro_locations; |
| } |
| |
| /* Get the location of the expansion point of the macro map MAP. */ |
| |
| inline location_t |
| MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro *macro_map) |
| { |
| return macro_map->expansion; |
| } |
| |
| /* The abstraction of a set of location maps. There can be several |
| types of location maps. This abstraction contains the attributes |
| that are independent from the type of the map. |
| |
| Essentially this is just a vector of T_linemap_subclass, |
| which can only ever grow in size. */ |
| |
| struct GTY(()) maps_info_ordinary { |
| /* This array contains the "ordinary" line maps, for all |
| events other than macro expansion |
| (e.g. when a new preprocessing unit starts or ends). */ |
| line_map_ordinary * GTY ((length ("%h.used"))) maps; |
| |
| /* The total number of allocated maps. */ |
| unsigned int allocated; |
| |
| /* The number of elements used in maps. This number is smaller |
| or equal to ALLOCATED. */ |
| unsigned int used; |
| |
| mutable unsigned int cache; |
| }; |
| |
| struct GTY(()) maps_info_macro { |
| /* This array contains the macro line maps. |
| A macro line map is created whenever a macro expansion occurs. */ |
| line_map_macro * GTY ((length ("%h.used"))) maps; |
| |
| /* The total number of allocated maps. */ |
| unsigned int allocated; |
| |
| /* The number of elements used in maps. This number is smaller |
| or equal to ALLOCATED. */ |
| unsigned int used; |
| |
| mutable unsigned int cache; |
| }; |
| |
| /* Data structure to associate a source_range together with an arbitrary |
| data pointer with a source location. */ |
| struct GTY(()) location_adhoc_data { |
| location_t locus; |
| source_range src_range; |
| void * GTY((skip)) data; |
| }; |
| |
| struct htab; |
| |
| /* The following data structure encodes a location with some adhoc data |
| and maps it to a new unsigned integer (called an adhoc location) |
| that replaces the original location to represent the mapping. |
| |
| The new adhoc_loc uses the highest bit as the enabling bit, i.e. if the |
| highest bit is 1, then the number is adhoc_loc. Otherwise, it serves as |
| the original location. Once identified as the adhoc_loc, the lower 31 |
| bits of the integer is used to index the location_adhoc_data array, |
| in which the locus and associated data is stored. */ |
| |
| struct GTY(()) location_adhoc_data_map { |
| struct htab * GTY((skip)) htab; |
| location_t curr_loc; |
| unsigned int allocated; |
| struct location_adhoc_data GTY((length ("%h.allocated"))) *data; |
| }; |
| |
| /* A set of chronological line_map structures. */ |
| class GTY(()) line_maps { |
| public: |
| |
| ~line_maps (); |
| |
| maps_info_ordinary info_ordinary; |
| |
| maps_info_macro info_macro; |
| |
| /* Depth of the include stack, including the current file. */ |
| unsigned int depth; |
| |
| /* If true, prints an include trace a la -H. */ |
| bool trace_includes; |
| |
| /* Highest location_t "given out". */ |
| location_t highest_location; |
| |
| /* Start of line of highest location_t "given out". */ |
| location_t highest_line; |
| |
| /* The maximum column number we can quickly allocate. Higher numbers |
| may require allocating a new line_map. */ |
| unsigned int max_column_hint; |
| |
| /* The allocator to use when resizing 'maps', defaults to xrealloc. */ |
| line_map_realloc reallocator; |
| |
| /* The allocators' function used to know the actual size it |
| allocated, for a certain allocation size requested. */ |
| line_map_round_alloc_size_func round_alloc_size; |
| |
| struct location_adhoc_data_map location_adhoc_data_map; |
| |
| /* The special location value that is used as spelling location for |
| built-in tokens. */ |
| location_t builtin_location; |
| |
| /* True if we've seen a #line or # 44 "file" directive. */ |
| bool seen_line_directive; |
| |
| /* The default value of range_bits in ordinary line maps. */ |
| unsigned int default_range_bits; |
| |
| unsigned int num_optimized_ranges; |
| unsigned int num_unoptimized_ranges; |
| }; |
| |
| /* Returns the number of allocated maps so far. MAP_KIND shall be TRUE |
| if we are interested in macro maps, FALSE otherwise. */ |
| inline unsigned int |
| LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind) |
| { |
| if (map_kind) |
| return set->info_macro.allocated; |
| else |
| return set->info_ordinary.allocated; |
| } |
| |
| /* As above, but by reference (e.g. as an lvalue). */ |
| |
| inline unsigned int & |
| LINEMAPS_ALLOCATED (line_maps *set, bool map_kind) |
| { |
| if (map_kind) |
| return set->info_macro.allocated; |
| else |
| return set->info_ordinary.allocated; |
| } |
| |
| /* Returns the number of used maps so far. MAP_KIND shall be TRUE if |
| we are interested in macro maps, FALSE otherwise.*/ |
| inline unsigned int |
| LINEMAPS_USED (const line_maps *set, bool map_kind) |
| { |
| if (map_kind) |
| return set->info_macro.used; |
| else |
| return set->info_ordinary.used; |
| } |
| |
| /* As above, but by reference (e.g. as an lvalue). */ |
| |
| inline unsigned int & |
| LINEMAPS_USED (line_maps *set, bool map_kind) |
| { |
| if (map_kind) |
| return set->info_macro.used; |
| else |
| return set->info_ordinary.used; |
| } |
| |
| /* Returns the index of the last map that was looked up with |
| linemap_lookup. MAP_KIND shall be TRUE if we are interested in |
| macro maps, FALSE otherwise. */ |
| inline unsigned int & |
| LINEMAPS_CACHE (const line_maps *set, bool map_kind) |
| { |
| if (map_kind) |
| return set->info_macro.cache; |
| else |
| return set->info_ordinary.cache; |
| } |
| |
| /* Return the map at a given index. */ |
| inline line_map * |
| LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int index) |
| { |
| if (map_kind) |
| return &set->info_macro.maps[index]; |
| else |
| return &set->info_ordinary.maps[index]; |
| } |
| |
| /* Returns the last map used in the line table SET. MAP_KIND |
| shall be TRUE if we are interested in macro maps, FALSE |
| otherwise.*/ |
| inline line_map * |
| LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind) |
| { |
| return LINEMAPS_MAP_AT (set, map_kind, |
| LINEMAPS_USED (set, map_kind) - 1); |
| } |
| |
| /* Returns the last map that was allocated in the line table SET. |
| MAP_KIND shall be TRUE if we are interested in macro maps, FALSE |
| otherwise.*/ |
| inline line_map * |
| LINEMAPS_LAST_ALLOCATED_MAP (const line_maps *set, bool map_kind) |
| { |
| return LINEMAPS_MAP_AT (set, map_kind, |
| LINEMAPS_ALLOCATED (set, map_kind) - 1); |
| } |
| |
| /* Returns a pointer to the memory region where ordinary maps are |
| allocated in the line table SET. */ |
| inline line_map_ordinary * |
| LINEMAPS_ORDINARY_MAPS (const line_maps *set) |
| { |
| return set->info_ordinary.maps; |
| } |
| |
| /* Returns the INDEXth ordinary map. */ |
| inline line_map_ordinary * |
| LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index) |
| { |
| linemap_assert (index >= 0 |
| && (unsigned int)index < LINEMAPS_USED (set, false)); |
| return (line_map_ordinary *)LINEMAPS_MAP_AT (set, false, index); |
| } |
| |
| /* Return the number of ordinary maps allocated in the line table |
| SET. */ |
| inline unsigned int |
| LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set) |
| { |
| return LINEMAPS_ALLOCATED (set, false); |
| } |
| |
| /* Return the number of ordinary maps used in the line table SET. */ |
| inline unsigned int |
| LINEMAPS_ORDINARY_USED (const line_maps *set) |
| { |
| return LINEMAPS_USED (set, false); |
| } |
| |
| /* Return the index of the last ordinary map that was looked up with |
| linemap_lookup. */ |
| inline unsigned int & |
| LINEMAPS_ORDINARY_CACHE (const line_maps *set) |
| { |
| return LINEMAPS_CACHE (set, false); |
| } |
| |
| /* Returns a pointer to the last ordinary map used in the line table |
| SET. */ |
| inline line_map_ordinary * |
| LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set) |
| { |
| return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, false); |
| } |
| |
| /* Returns a pointer to the last ordinary map allocated the line table |
| SET. */ |
| inline line_map_ordinary * |
| LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps *set) |
| { |
| return (line_map_ordinary *)LINEMAPS_LAST_ALLOCATED_MAP (set, false); |
| } |
| |
| /* Returns a pointer to the beginning of the region where macro maps |
| are allocated. */ |
| inline line_map_macro * |
| LINEMAPS_MACRO_MAPS (const line_maps *set) |
| { |
| return set->info_macro.maps; |
| } |
| |
| /* Returns the INDEXth macro map. */ |
| inline line_map_macro * |
| LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index) |
| { |
| linemap_assert (index >= 0 |
| && (unsigned int)index < LINEMAPS_USED (set, true)); |
| return (line_map_macro *)LINEMAPS_MAP_AT (set, true, index); |
| } |
| |
| /* Returns the number of macro maps that were allocated in the line |
| table SET. */ |
| inline unsigned int |
| LINEMAPS_MACRO_ALLOCATED (const line_maps *set) |
| { |
| return LINEMAPS_ALLOCATED (set, true); |
| } |
| |
| /* Returns the number of macro maps used in the line table SET. */ |
| inline unsigned int |
| LINEMAPS_MACRO_USED (const line_maps *set) |
| { |
| return LINEMAPS_USED (set, true); |
| } |
| |
| /* Return the index of the last macro map that was looked up with |
| linemap_lookup. */ |
| inline unsigned int & |
| LINEMAPS_MACRO_CACHE (const line_maps *set) |
| { |
| return LINEMAPS_CACHE (set, true); |
| } |
| |
| /* Returns the last macro map used in the line table SET. */ |
| inline line_map_macro * |
| LINEMAPS_LAST_MACRO_MAP (const line_maps *set) |
| { |
| return (line_map_macro *)LINEMAPS_LAST_MAP (set, true); |
| } |
| |
| /* Returns the lowest location [of a token resulting from macro |
| expansion] encoded in this line table. */ |
| inline location_t |
| LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set) |
| { |
| return LINEMAPS_MACRO_USED (set) |
| ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set)) |
| : MAX_LOCATION_T + 1; |
| } |
| |
| /* Returns the last macro map allocated in the line table SET. */ |
| inline line_map_macro * |
| LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set) |
| { |
| return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true); |
| } |
| |
| extern location_t get_combined_adhoc_loc (line_maps *, location_t, |
| source_range, void *); |
| extern void *get_data_from_adhoc_loc (const line_maps *, location_t); |
| extern location_t get_location_from_adhoc_loc (const line_maps *, |
| location_t); |
| |
| extern source_range get_range_from_loc (line_maps *set, location_t loc); |
| |
| /* Get whether location LOC is a "pure" location, or |
| whether it is an ad-hoc location, or embeds range information. */ |
| |
| bool |
| pure_location_p (line_maps *set, location_t loc); |
| |
| /* Given location LOC within SET, strip away any packed range information |
| or ad-hoc information. */ |
| |
| extern location_t get_pure_location (line_maps *set, location_t loc); |
| |
| /* Combine LOC and BLOCK, giving a combined adhoc location. */ |
| |
| inline location_t |
| COMBINE_LOCATION_DATA (class line_maps *set, |
| location_t loc, |
| source_range src_range, |
| void *block) |
| { |
| return get_combined_adhoc_loc (set, loc, src_range, block); |
| } |
| |
| extern void rebuild_location_adhoc_htab (class line_maps *); |
| |
| /* Initialize a line map set. SET is the line map set to initialize |
| and BUILTIN_LOCATION is the special location value to be used as |
| spelling location for built-in tokens. This BUILTIN_LOCATION has |
| to be strictly less than RESERVED_LOCATION_COUNT. */ |
| extern void linemap_init (class line_maps *set, |
| location_t builtin_location); |
| |
| /* Check for and warn about line_maps entered but not exited. */ |
| |
| extern void linemap_check_files_exited (class line_maps *); |
| |
| /* Return a location_t for the start (i.e. column==0) of |
| (physical) line TO_LINE in the current source file (as in the |
| most recent linemap_add). MAX_COLUMN_HINT is the highest column |
| number we expect to use in this line (but it does not change |
| the highest_location). */ |
| |
| extern location_t linemap_line_start |
| (class line_maps *set, linenum_type to_line, unsigned int max_column_hint); |
| |
| /* Allocate a raw block of line maps, zero initialized. */ |
| extern line_map *line_map_new_raw (line_maps *, bool, unsigned); |
| |
| /* Add a mapping of logical source line to physical source file and |
| line number. This function creates an "ordinary map", which is a |
| map that records locations of tokens that are not part of macro |
| replacement-lists present at a macro expansion point. |
| |
| The text pointed to by TO_FILE must have a lifetime |
| at least as long as the lifetime of SET. An empty |
| TO_FILE means standard input. If reason is LC_LEAVE, and |
| TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their |
| natural values considering the file we are returning to. |
| |
| A call to this function can relocate the previous set of |
| maps, so any stored line_map pointers should not be used. */ |
| extern const line_map *linemap_add |
| (class line_maps *, enum lc_reason, unsigned int sysp, |
| const char *to_file, linenum_type to_line); |
| |
| /* Create a macro map. A macro map encodes source locations of tokens |
| that are part of a macro replacement-list, at a macro expansion |
| point. See the extensive comments of struct line_map and struct |
| line_map_macro, in line-map.h. |
| |
| This map shall be created when the macro is expanded. The map |
| encodes the source location of the expansion point of the macro as |
| well as the "original" source location of each token that is part |
| of the macro replacement-list. If a macro is defined but never |
| expanded, it has no macro map. SET is the set of maps the macro |
| map should be part of. MACRO_NODE is the macro which the new macro |
| map should encode source locations for. EXPANSION is the location |
| of the expansion point of MACRO. For function-like macros |
| invocations, it's best to make it point to the closing parenthesis |
| of the macro, rather than the the location of the first character |
| of the macro. NUM_TOKENS is the number of tokens that are part of |
| the replacement-list of MACRO. */ |
| const line_map_macro *linemap_enter_macro (line_maps *, cpp_hashnode *, |
| location_t, unsigned int); |
| |
| /* Create a source location for a module. The creator must either do |
| this after the TU is tokenized, or deal with saving and restoring |
| map state. */ |
| |
| extern location_t linemap_module_loc |
| (line_maps *, location_t from, const char *name); |
| extern void linemap_module_reparent |
| (line_maps *, location_t loc, location_t new_parent); |
| |
| /* Restore the linemap state such that the map at LWM-1 continues. |
| Return start location of the new map. */ |
| extern unsigned linemap_module_restore |
| (line_maps *, unsigned lwm); |
| |
| /* Given a logical source location, returns the map which the |
| corresponding (source file, line, column) triplet can be deduced |
| from. Since the set is built chronologically, the logical lines are |
| monotonic increasing, and so the list is sorted and we can use a |
| binary search. If no line map have been allocated yet, this |
| function returns NULL. */ |
| extern const line_map *linemap_lookup |
| (const line_maps *, location_t); |
| |
| unsigned linemap_lookup_macro_index (const line_maps *, location_t); |
| |
| /* Returns TRUE if the line table set tracks token locations across |
| macro expansion, FALSE otherwise. */ |
| bool linemap_tracks_macro_expansion_locs_p (class line_maps *); |
| |
| /* Return the name of the macro associated to MACRO_MAP. */ |
| const char* linemap_map_get_macro_name (const line_map_macro *); |
| |
| /* Return a positive value if LOCATION is the locus of a token that is |
| located in a system header, O otherwise. It returns 1 if LOCATION |
| is the locus of a token that is located in a system header, and 2 |
| if LOCATION is the locus of a token located in a C system header |
| that therefore needs to be extern "C" protected in C++. |
| |
| Note that this function returns 1 if LOCATION belongs to a token |
| that is part of a macro replacement-list defined in a system |
| header, but expanded in a non-system file. */ |
| int linemap_location_in_system_header_p (class line_maps *, |
| location_t); |
| |
| /* Return TRUE if LOCATION is a source code location of a token that is part of |
| a macro expansion, FALSE otherwise. */ |
| bool linemap_location_from_macro_expansion_p (const line_maps *, |
| location_t); |
| |
| /* TRUE if LOCATION is a source code location of a token that is part of the |
| definition of a macro, FALSE otherwise. */ |
| bool linemap_location_from_macro_definition_p (class line_maps *, |
| location_t); |
| |
| /* With the precondition that LOCATION is the locus of a token that is |
| an argument of a function-like macro MACRO_MAP and appears in the |
| expansion of MACRO_MAP, return the locus of that argument in the |
| context of the caller of MACRO_MAP. */ |
| |
| extern location_t linemap_macro_map_loc_unwind_toward_spelling |
| (line_maps *set, const line_map_macro *macro_map, location_t location); |
| |
| /* location_t values from 0 to RESERVED_LOCATION_COUNT-1 will |
| be reserved for libcpp user as special values, no token from libcpp |
| will contain any of those locations. */ |
| const location_t RESERVED_LOCATION_COUNT = 2; |
| |
| /* Converts a map and a location_t to source line. */ |
| inline linenum_type |
| SOURCE_LINE (const line_map_ordinary *ord_map, location_t loc) |
| { |
| return ((loc - ord_map->start_location) |
| >> ord_map->m_column_and_range_bits) + ord_map->to_line; |
| } |
| |
| /* Convert a map and location_t to source column number. */ |
| inline linenum_type |
| SOURCE_COLUMN (const line_map_ordinary *ord_map, location_t loc) |
| { |
| return ((loc - ord_map->start_location) |
| & ((1 << ord_map->m_column_and_range_bits) - 1)) >> ord_map->m_range_bits; |
| } |
| |
| |
| inline location_t |
| linemap_included_from (const line_map_ordinary *ord_map) |
| { |
| return ord_map->included_from; |
| } |
| |
| /* The linemap containing the included-from location of MAP. */ |
| const line_map_ordinary *linemap_included_from_linemap |
| (line_maps *set, const line_map_ordinary *map); |
| |
| /* True if the map is at the bottom of the include stack. */ |
| |
| inline bool |
| MAIN_FILE_P (const line_map_ordinary *ord_map) |
| { |
| return ord_map->included_from == 0; |
| } |
| |
| /* Encode and return a location_t from a column number. The |
| source line considered is the last source line used to call |
| linemap_line_start, i.e, the last source line which a location was |
| encoded from. */ |
| extern location_t |
| linemap_position_for_column (class line_maps *, unsigned int); |
| |
| /* Encode and return a source location from a given line and |
| column. */ |
| location_t |
| linemap_position_for_line_and_column (line_maps *set, |
| const line_map_ordinary *, |
| linenum_type, unsigned int); |
| |
| /* Encode and return a location_t starting from location LOC and |
| shifting it by OFFSET columns. This function does not support |
| virtual locations. */ |
| location_t |
| linemap_position_for_loc_and_offset (class line_maps *set, |
| location_t loc, |
| unsigned int offset); |
| |
| /* Return the file this map is for. */ |
| inline const char * |
| LINEMAP_FILE (const line_map_ordinary *ord_map) |
| { |
| return ord_map->to_file; |
| } |
| |
| /* Return the line number this map started encoding location from. */ |
| inline linenum_type |
| LINEMAP_LINE (const line_map_ordinary *ord_map) |
| { |
| return ord_map->to_line; |
| } |
| |
| /* Return a positive value if map encodes locations from a system |
| header, 0 otherwise. Returns 1 if MAP encodes locations in a |
| system header and 2 if it encodes locations in a C system header |
| that therefore needs to be extern "C" protected in C++. */ |
| inline unsigned char |
| LINEMAP_SYSP (const line_map_ordinary *ord_map) |
| { |
| return ord_map->sysp; |
| } |
| |
| const struct line_map *first_map_in_common (line_maps *set, |
| location_t loc0, |
| location_t loc1, |
| location_t *res_loc0, |
| location_t *res_loc1); |
| |
| /* Return a positive value if PRE denotes the location of a token that |
| comes before the token of POST, 0 if PRE denotes the location of |
| the same token as the token for POST, and a negative value |
| otherwise. */ |
| int linemap_compare_locations (class line_maps *set, |
| location_t pre, |
| location_t post); |
| |
| /* Return TRUE if LOC_A denotes the location a token that comes |
| topogically before the token denoted by location LOC_B, or if they |
| are equal. */ |
| inline bool |
| linemap_location_before_p (class line_maps *set, |
| location_t loc_a, |
| location_t loc_b) |
| { |
| return linemap_compare_locations (set, loc_a, loc_b) >= 0; |
| } |
| |
| typedef struct |
| { |
| /* The name of the source file involved. */ |
| const char *file; |
| |
| /* The line-location in the source file. */ |
| int line; |
| |
| int column; |
| |
| void *data; |
| |
| /* In a system header?. */ |
| bool sysp; |
| } expanded_location; |
| |
| class range_label; |
| |
| /* A hint to diagnostic_show_locus on how to print a source range within a |
| rich_location. |
| |
| Typically this is SHOW_RANGE_WITH_CARET for the 0th range, and |
| SHOW_RANGE_WITHOUT_CARET for subsequent ranges, |
| but the Fortran frontend uses SHOW_RANGE_WITH_CARET repeatedly for |
| printing things like: |
| |
| x = x + y |
| 1 2 |
| Error: Shapes for operands at (1) and (2) are not conformable |
| |
| where "1" and "2" are notionally carets. */ |
| |
| enum range_display_kind |
| { |
| /* Show the pertinent source line(s), the caret, and underline(s). */ |
| SHOW_RANGE_WITH_CARET, |
| |
| /* Show the pertinent source line(s) and underline(s), but don't |
| show the caret (just an underline). */ |
| SHOW_RANGE_WITHOUT_CARET, |
| |
| /* Just show the source lines; don't show the range itself. |
| This is for use when displaying some line-insertion fix-it hints (for |
| showing the user context on the change, for when it doesn't make sense |
| to highlight the first column on the next line). */ |
| SHOW_LINES_WITHOUT_RANGE |
| }; |
| |
| /* A location within a rich_location: a caret&range, with |
| the caret potentially flagged for display, and an optional |
| label. */ |
| |
| struct location_range |
| { |
| location_t m_loc; |
| |
| enum range_display_kind m_range_display_kind; |
| |
| /* If non-NULL, the label for this range. */ |
| const range_label *m_label; |
| }; |
| |
| /* A partially-embedded vec for use within rich_location for storing |
| ranges and fix-it hints. |
| |
| Elements [0..NUM_EMBEDDED) are allocated within m_embed, after |
| that they are within the dynamically-allocated m_extra. |
| |
| This allows for static allocation in the common case, whilst |
| supporting the rarer case of an arbitrary number of elements. |
| |
| Dynamic allocation is not performed unless it's needed. */ |
| |
| template <typename T, int NUM_EMBEDDED> |
| class semi_embedded_vec |
| { |
| public: |
| semi_embedded_vec (); |
| ~semi_embedded_vec (); |
| |
| unsigned int count () const { return m_num; } |
| T& operator[] (int idx); |
| const T& operator[] (int idx) const; |
| |
| void push (const T&); |
| void truncate (int len); |
| |
| private: |
| int m_num; |
| T m_embedded[NUM_EMBEDDED]; |
| int m_alloc; |
| T *m_extra; |
| }; |
| |
| /* Constructor for semi_embedded_vec. In particular, no dynamic allocation |
| is done. */ |
| |
| template <typename T, int NUM_EMBEDDED> |
| semi_embedded_vec<T, NUM_EMBEDDED>::semi_embedded_vec () |
| : m_num (0), m_alloc (0), m_extra (NULL) |
| { |
| } |
| |
| /* semi_embedded_vec's dtor. Release any dynamically-allocated memory. */ |
| |
| template <typename T, int NUM_EMBEDDED> |
| semi_embedded_vec<T, NUM_EMBEDDED>::~semi_embedded_vec () |
| { |
| XDELETEVEC (m_extra); |
| } |
| |
| /* Look up element IDX, mutably. */ |
| |
| template <typename T, int NUM_EMBEDDED> |
| T& |
| semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) |
| { |
| linemap_assert (idx < m_num); |
| if (idx < NUM_EMBEDDED) |
| return m_embedded[idx]; |
| else |
| { |
| linemap_assert (m_extra != NULL); |
| return m_extra[idx - NUM_EMBEDDED]; |
| } |
| } |
| |
| /* Look up element IDX (const). */ |
| |
| template <typename T, int NUM_EMBEDDED> |
| const T& |
| semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) const |
| { |
| linemap_assert (idx < m_num); |
| if (idx < NUM_EMBEDDED) |
| return m_embedded[idx]; |
| else |
| { |
| linemap_assert (m_extra != NULL); |
| return m_extra[idx - NUM_EMBEDDED]; |
| } |
| } |
| |
| /* Append VALUE to the end of the semi_embedded_vec. */ |
| |
| template <typename T, int NUM_EMBEDDED> |
| void |
| semi_embedded_vec<T, NUM_EMBEDDED>::push (const T& value) |
| { |
| int idx = m_num++; |
| if (idx < NUM_EMBEDDED) |
| m_embedded[idx] = value; |
| else |
| { |
| /* Offset "idx" to be an index within m_extra. */ |
| idx -= NUM_EMBEDDED; |
| if (NULL == m_extra) |
| { |
| linemap_assert (m_alloc == 0); |
| m_alloc = 16; |
| m_extra = XNEWVEC (T, m_alloc); |
| } |
| else if (idx >= m_alloc) |
| { |
| linemap_assert (m_alloc > 0); |
| m_alloc *= 2; |
| m_extra = XRESIZEVEC (T, m_extra, m_alloc); |
| } |
| linemap_assert (m_extra); |
| linemap_assert (idx < m_alloc); |
| m_extra[idx] = value; |
| } |
| } |
| |
| /* Truncate to length LEN. No deallocation is performed. */ |
| |
| template <typename T, int NUM_EMBEDDED> |
| void |
| semi_embedded_vec<T, NUM_EMBEDDED>::truncate (int len) |
| { |
| linemap_assert (len <= m_num); |
| m_num = len; |
| } |
| |
| class fixit_hint; |
| class diagnostic_path; |
| |
| /* A "rich" source code location, for use when printing diagnostics. |
| A rich_location has one or more carets&ranges, where the carets |
| are optional. These are referred to as "ranges" from here. |
| Typically the zeroth range has a caret; other ranges sometimes |
| have carets. |
| |
| The "primary" location of a rich_location is the caret of range 0, |
| used for determining the line/column when printing diagnostic |
| text, such as: |
| |
| some-file.c:3:1: error: ...etc... |
| |
| Additional ranges may be added to help the user identify other |
| pertinent clauses in a diagnostic. |
| |
| Ranges can (optionally) be given labels via class range_label. |
| |
| rich_location instances are intended to be allocated on the stack |
| when generating diagnostics, and to be short-lived. |
| |
| Examples of rich locations |
| -------------------------- |
| |
| Example A |
| ********* |
| int i = "foo"; |
| ^ |
| This "rich" location is simply a single range (range 0), with |
| caret = start = finish at the given point. |
| |
| Example B |
| ********* |
| a = (foo && bar) |
| ~~~~~^~~~~~~ |
| This rich location has a single range (range 0), with the caret |
| at the first "&", and the start/finish at the parentheses. |
| Compare with example C below. |
| |
| Example C |
| ********* |
| a = (foo && bar) |
| ~~~ ^~ ~~~ |
| This rich location has three ranges: |
| - Range 0 has its caret and start location at the first "&" and |
| end at the second "&. |
| - Range 1 has its start and finish at the "f" and "o" of "foo"; |
| the caret is not flagged for display, but is perhaps at the "f" |
| of "foo". |
| - Similarly, range 2 has its start and finish at the "b" and "r" of |
| "bar"; the caret is not flagged for display, but is perhaps at the |
| "b" of "bar". |
| Compare with example B above. |
| |
| Example D (Fortran frontend) |
| **************************** |
| x = x + y |
| 1 2 |
| This rich location has range 0 at "1", and range 1 at "2". |
| Both are flagged for caret display. Both ranges have start/finish |
| equal to their caret point. The frontend overrides the diagnostic |
| context's default caret character for these ranges. |
| |
| Example E (range labels) |
| ************************ |
| printf ("arg0: %i arg1: %s arg2: %i", |
| ^~ |
| | |
| const char * |
| 100, 101, 102); |
| ~~~ |
| | |
| int |
| This rich location has two ranges: |
| - range 0 is at the "%s" with start = caret = "%" and finish at |
| the "s". It has a range_label ("const char *"). |
| - range 1 has start/finish covering the "101" and is not flagged for |
| caret printing. The caret is at the start of "101", where its |
| range_label is printed ("int"). |
| |
| Fix-it hints |
| ------------ |
| |
| Rich locations can also contain "fix-it hints", giving suggestions |
| for the user on how to edit their code to fix a problem. These |
| can be expressed as insertions, replacements, and removals of text. |
| The edits by default are relative to the zeroth range within the |
| rich_location, but optionally they can be expressed relative to |
| other locations (using various overloaded methods of the form |
| rich_location::add_fixit_*). |
| |
| For example: |
| |
| Example F: fix-it hint: insert_before |
| ************************************* |
| ptr = arr[0]; |
| ^~~~~~ |
| & |
| This rich location has a single range (range 0) covering "arr[0]", |
| with the caret at the start. The rich location has a single |
| insertion fix-it hint, inserted before range 0, added via |
| richloc.add_fixit_insert_before ("&"); |
| |
| Example G: multiple fix-it hints: insert_before and insert_after |
| **************************************************************** |
| #define FN(ARG0, ARG1, ARG2) fn(ARG0, ARG1, ARG2) |
| ^~~~ ^~~~ ^~~~ |
| ( ) ( ) ( ) |
| This rich location has three ranges, covering "arg0", "arg1", |
| and "arg2", all with caret-printing enabled. |
| The rich location has 6 insertion fix-it hints: each arg |
| has a pair of insertion fix-it hints, suggesting wrapping |
| them with parentheses: one a '(' inserted before, |
| the other a ')' inserted after, added via |
| richloc.add_fixit_insert_before (LOC, "("); |
| and |
| richloc.add_fixit_insert_after (LOC, ")"); |
| |
| Example H: fix-it hint: removal |
| ******************************* |
| struct s {int i};; |
| ^ |
| - |
| This rich location has a single range at the stray trailing |
| semicolon, along with a single removal fix-it hint, covering |
| the same range, added via: |
| richloc.add_fixit_remove (); |
| |
| Example I: fix-it hint: replace |
| ******************************* |
| c = s.colour; |
| ^~~~~~ |
| color |
| This rich location has a single range (range 0) covering "colour", |
| and a single "replace" fix-it hint, covering the same range, |
| added via |
| richloc.add_fixit_replace ("color"); |
| |
| Example J: fix-it hint: line insertion |
| ************************************** |
| |
| 3 | #include <stddef.h> |
| + |+#include <stdio.h> |
| 4 | int the_next_line; |
| |
| This rich location has a single range at line 4 column 1, marked |
| with SHOW_LINES_WITHOUT_RANGE (to avoid printing a meaningless caret |
| on the "i" of int). It has a insertion fix-it hint of the string |
| "#include <stdio.h>\n". |
| |
| Adding a fix-it hint can fail: for example, attempts to insert content |
| at the transition between two line maps may fail due to there being no |
| location_t value to express the new location. |
| |
| Attempts to add a fix-it hint within a macro expansion will fail. |
| |
| There is only limited support for newline characters in fix-it hints: |
| only hints with newlines which insert an entire new line are permitted, |
| inserting at the start of a line, and finishing with a newline |
| (with no interior newline characters). Other attempts to add |
| fix-it hints containing newline characters will fail. |
| Similarly, attempts to delete or replace a range *affecting* multiple |
| lines will fail. |
| |
| The rich_location API handles these failures gracefully, so that |
| diagnostics can attempt to add fix-it hints without each needing |
| extensive checking. |
| |
| Fix-it hints within a rich_location are "atomic": if any hints can't |
| be applied, none of them will be (tracked by the m_seen_impossible_fixit |
| flag), and no fix-its hints will be displayed for that rich_location. |
| This implies that diagnostic messages need to be worded in such a way |
| that they make sense whether or not the fix-it hints are displayed, |
| or that richloc.seen_impossible_fixit_p () should be checked before |
| issuing the diagnostics. */ |
| |
| class rich_location |
| { |
| public: |
| /* Constructors. */ |
| |
| /* Constructing from a location. */ |
| rich_location (line_maps *set, location_t loc, |
| const range_label *label = NULL); |
| |
| /* Destructor. */ |
| ~rich_location (); |
| |
| /* The class manages the memory pointed to by the elements of |
| the M_FIXIT_HINTS vector and is not meant to be copied or |
| assigned. */ |
| rich_location (const rich_location &) = delete; |
| void operator= (const rich_location &) = delete; |
| |
| /* Accessors. */ |
| location_t get_loc () const { return get_loc (0); } |
| location_t get_loc (unsigned int idx) const; |
| |
| void |
| add_range (location_t loc, |
| enum range_display_kind range_display_kind |
| = SHOW_RANGE_WITHOUT_CARET, |
| const range_label *label = NULL); |
| |
| void |
| set_range (unsigned int idx, location_t loc, |
| enum range_display_kind range_display_kind); |
| |
| unsigned int get_num_locations () const { return m_ranges.count (); } |
| |
| const location_range *get_range (unsigned int idx) const; |
| location_range *get_range (unsigned int idx); |
| |
| expanded_location get_expanded_location (unsigned int idx); |
| |
| void |
| override_column (int column); |
| |
| /* Fix-it hints. */ |
| |
| /* Methods for adding insertion fix-it hints. */ |
| |
| /* Suggest inserting NEW_CONTENT immediately before the primary |
| range's start. */ |
| void |
| add_fixit_insert_before (const char *new_content); |
| |
| /* Suggest inserting NEW_CONTENT immediately before the start of WHERE. */ |
| void |
| add_fixit_insert_before (location_t where, |
| const char *new_content); |
| |
| /* Suggest inserting NEW_CONTENT immediately after the end of the primary |
| range. */ |
| void |
| add_fixit_insert_after (const char *new_content); |
| |
| /* Suggest inserting NEW_CONTENT immediately after the end of WHERE. */ |
| void |
| add_fixit_insert_after (location_t where, |
| const char *new_content); |
| |
| /* Methods for adding removal fix-it hints. */ |
| |
| /* Suggest removing the content covered by range 0. */ |
| void |
| add_fixit_remove (); |
| |
| /* Suggest removing the content covered between the start and finish |
| of WHERE. */ |
| void |
| add_fixit_remove (location_t where); |
| |
| /* Suggest removing the content covered by SRC_RANGE. */ |
| void |
| add_fixit_remove (source_range src_range); |
| |
| /* Methods for adding "replace" fix-it hints. */ |
| |
| /* Suggest replacing the content covered by range 0 with NEW_CONTENT. */ |
| void |
| add_fixit_replace (const char *new_content); |
| |
| /* Suggest replacing the content between the start and finish of |
| WHERE with NEW_CONTENT. */ |
| void |
| add_fixit_replace (location_t where, |
| const char *new_content); |
| |
| /* Suggest replacing the content covered by SRC_RANGE with |
| NEW_CONTENT. */ |
| void |
| add_fixit_replace (source_range src_range, |
| const char *new_content); |
| |
| unsigned int get_num_fixit_hints () const { return m_fixit_hints.count (); } |
| fixit_hint *get_fixit_hint (int idx) const { return m_fixit_hints[idx]; } |
| fixit_hint *get_last_fixit_hint () const; |
| bool seen_impossible_fixit_p () const { return m_seen_impossible_fixit; } |
| |
| /* Set this if the fix-it hints are not suitable to be |
| automatically applied. |
| |
| For example, if you are suggesting more than one |
| mutually exclusive solution to a problem, then |
| it doesn't make sense to apply all of the solutions; |
| manual intervention is required. |
| |
| If set, then the fix-it hints in the rich_location will |
| be printed, but will not be added to generated patches, |
| or affect the modified version of the file. */ |
| void fixits_cannot_be_auto_applied () |
| { |
| m_fixits_cannot_be_auto_applied = true; |
| } |
| |
| bool fixits_can_be_auto_applied_p () const |
| { |
| return !m_fixits_cannot_be_auto_applied; |
| } |
| |
| /* An optional path through the code. */ |
| const diagnostic_path *get_path () const { return m_path; } |
| void set_path (const diagnostic_path *path) { m_path = path; } |
| |
| private: |
| bool reject_impossible_fixit (location_t where); |
| void stop_supporting_fixits (); |
| void maybe_add_fixit (location_t start, |
| location_t next_loc, |
| const char *new_content); |
| |
| public: |
| static const int STATICALLY_ALLOCATED_RANGES = 3; |
| |
| protected: |
| line_maps *m_line_table; |
| semi_embedded_vec <location_range, STATICALLY_ALLOCATED_RANGES> m_ranges; |
| |
| int m_column_override; |
| |
| bool m_have_expanded_location; |
| expanded_location m_expanded_location; |
| |
| static const int MAX_STATIC_FIXIT_HINTS = 2; |
| semi_embedded_vec <fixit_hint *, MAX_STATIC_FIXIT_HINTS> m_fixit_hints; |
| |
| bool m_seen_impossible_fixit; |
| bool m_fixits_cannot_be_auto_applied; |
| |
| const diagnostic_path *m_path; |
| }; |
| |
| /* A struct for the result of range_label::get_text: a NUL-terminated buffer |
| of localized text, and a flag to determine if the caller should "free" the |
| buffer. */ |
| |
| class label_text |
| { |
| public: |
| label_text () |
| : m_buffer (NULL), m_caller_owned (false) |
| {} |
| |
| void maybe_free () |
| { |
| if (m_caller_owned) |
| free (m_buffer); |
| } |
| |
| /* Create a label_text instance that borrows BUFFER from a |
| longer-lived owner. */ |
| static label_text borrow (const char *buffer) |
| { |
| return label_text (const_cast <char *> (buffer), false); |
| } |
| |
| /* Create a label_text instance that takes ownership of BUFFER. */ |
| static label_text take (char *buffer) |
| { |
| return label_text (buffer, true); |
| } |
| |
| /* Take ownership of the buffer, copying if necessary. */ |
| char *take_or_copy () |
| { |
| if (m_caller_owned) |
| return m_buffer; |
| else |
| return xstrdup (m_buffer); |
| } |
| |
| char *m_buffer; |
| bool m_caller_owned; |
| |
| private: |
| label_text (char *buffer, bool owned) |
| : m_buffer (buffer), m_caller_owned (owned) |
| {} |
| }; |
| |
| /* Abstract base class for labelling a range within a rich_location |
| (e.g. for labelling expressions with their type). |
| |
| Generating the text could require non-trivial work, so this work |
| is delayed (via the "get_text" virtual function) until the diagnostic |
| printing code "knows" it needs it, thus avoiding doing it e.g. for |
| warnings that are filtered by command-line flags. This virtual |
| function also isolates libcpp and the diagnostics subsystem from |
| the front-end and middle-end-specific code for generating the text |
| for the labels. |
| |
| Like the rich_location instances they annotate, range_label instances |
| are intended to be allocated on the stack when generating diagnostics, |
| and to be short-lived. */ |
| |
| class range_label |
| { |
| public: |
| virtual ~range_label () {} |
| |
| /* Get localized text for the label. |
| The RANGE_IDX is provided, allowing for range_label instances to be |
| shared by multiple ranges if need be (the "flyweight" design pattern). */ |
| virtual label_text get_text (unsigned range_idx) const = 0; |
| }; |
| |
| /* A fix-it hint: a suggested insertion, replacement, or deletion of text. |
| We handle these three types of edit with one class, by representing |
| them as replacement of a half-open range: |
| [start, next_loc) |
| Insertions have start == next_loc: "replace" the empty string at the |
| start location with the new string. |
| Deletions are replacement with the empty string. |
| |
| There is only limited support for newline characters in fix-it hints |
| as noted above in the comment for class rich_location. |
| A fixit_hint instance can have at most one newline character; if |
| present, the newline character must be the final character of |
| the content (preventing e.g. fix-its that split a pre-existing line). */ |
| |
| class fixit_hint |
| { |
| public: |
| fixit_hint (location_t start, |
| location_t next_loc, |
| const char *new_content); |
| ~fixit_hint () { free (m_bytes); } |
| |
| bool affects_line_p (const char *file, int line) const; |
| location_t get_start_loc () const { return m_start; } |
| location_t get_next_loc () const { return m_next_loc; } |
| bool maybe_append (location_t start, |
| location_t next_loc, |
| const char *new_content); |
| |
| const char *get_string () const { return m_bytes; } |
| size_t get_length () const { return m_len; } |
| |
| bool insertion_p () const { return m_start == m_next_loc; } |
| |
| bool ends_with_newline_p () const; |
| |
| private: |
| /* We don't use source_range here since, unlike most places, |
| this is a half-open/half-closed range: |
| [start, next_loc) |
| so that we can support insertion via start == next_loc. */ |
| location_t m_start; |
| location_t m_next_loc; |
| char *m_bytes; |
| size_t m_len; |
| }; |
| |
| |
| /* This is enum is used by the function linemap_resolve_location |
| below. The meaning of the values is explained in the comment of |
| that function. */ |
| enum location_resolution_kind |
| { |
| LRK_MACRO_EXPANSION_POINT, |
| LRK_SPELLING_LOCATION, |
| LRK_MACRO_DEFINITION_LOCATION |
| }; |
| |
| /* Resolve a virtual location into either a spelling location, an |
| expansion point location or a token argument replacement point |
| location. Return the map that encodes the virtual location as well |
| as the resolved location. |
| |
| If LOC is *NOT* the location of a token resulting from the |
| expansion of a macro, then the parameter LRK (which stands for |
| Location Resolution Kind) is ignored and the resulting location |
| just equals the one given in argument. |
| |
| Now if LOC *IS* the location of a token resulting from the |
| expansion of a macro, this is what happens. |
| |
| * If LRK is set to LRK_MACRO_EXPANSION_POINT |
| ------------------------------- |
| |
| The virtual location is resolved to the first macro expansion point |
| that led to this macro expansion. |
| |
| * If LRK is set to LRK_SPELLING_LOCATION |
| ------------------------------------- |
| |
| The virtual location is resolved to the locus where the token has |
| been spelled in the source. This can follow through all the macro |
| expansions that led to the token. |
| |
| * If LRK is set to LRK_MACRO_DEFINITION_LOCATION |
| -------------------------------------- |
| |
| The virtual location is resolved to the locus of the token in the |
| context of the macro definition. |
| |
| If LOC is the locus of a token that is an argument of a |
| function-like macro [replacing a parameter in the replacement list |
| of the macro] the virtual location is resolved to the locus of the |
| parameter that is replaced, in the context of the definition of the |
| macro. |
| |
| If LOC is the locus of a token that is not an argument of a |
| function-like macro, then the function behaves as if LRK was set to |
| LRK_SPELLING_LOCATION. |
| |
| If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the |
| returned location. Note that if the returned location wasn't originally |
| encoded by a map, the *MAP is set to NULL. This can happen if LOC |
| resolves to a location reserved for the client code, like |
| UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */ |
| |
| location_t linemap_resolve_location (class line_maps *, |
| location_t loc, |
| enum location_resolution_kind lrk, |
| const line_map_ordinary **loc_map); |
| |
| /* Suppose that LOC is the virtual location of a token coming from the |
| expansion of a macro M. This function then steps up to get the |
| location L of the point where M got expanded. If L is a spelling |
| location inside a macro expansion M', then this function returns |
| the point where M' was expanded. LOC_MAP is an output parameter. |
| When non-NULL, *LOC_MAP is set to the map of the returned |
| location. */ |
| location_t linemap_unwind_toward_expansion (class line_maps *, |
| location_t loc, |
| const line_map **loc_map); |
| |
| /* If LOC is the virtual location of a token coming from the expansion |
| of a macro M and if its spelling location is reserved (e.g, a |
| location for a built-in token), then this function unwinds (using |
| linemap_unwind_toward_expansion) the location until a location that |
| is not reserved and is not in a system header is reached. In other |
| words, this unwinds the reserved location until a location that is |
| in real source code is reached. |
| |
| Otherwise, if the spelling location for LOC is not reserved or if |
| LOC doesn't come from the expansion of a macro, the function |
| returns LOC as is and *MAP is not touched. |
| |
| *MAP is set to the map of the returned location if the later is |
| different from LOC. */ |
| location_t linemap_unwind_to_first_non_reserved_loc (class line_maps *, |
| location_t loc, |
| const line_map **map); |
| |
| /* Expand source code location LOC and return a user readable source |
| code location. LOC must be a spelling (non-virtual) location. If |
| it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source |
| location is returned. */ |
| expanded_location linemap_expand_location (class line_maps *, |
| const line_map *, |
| location_t loc); |
| |
| /* Statistics about maps allocation and usage as returned by |
| linemap_get_statistics. */ |
| struct linemap_stats |
| { |
| long num_ordinary_maps_allocated; |
| long num_ordinary_maps_used; |
| long ordinary_maps_allocated_size; |
| long ordinary_maps_used_size; |
| long num_expanded_macros; |
| long num_macro_tokens; |
| long num_macro_maps_used; |
| long macro_maps_allocated_size; |
| long macro_maps_used_size; |
| long macro_maps_locations_size; |
| long duplicated_macro_maps_locations_size; |
| long adhoc_table_size; |
| long adhoc_table_entries_used; |
| }; |
| |
| /* Return the highest location emitted for a given file for which |
| there is a line map in SET. FILE_NAME is the file name to |
| consider. If the function returns TRUE, *LOC is set to the highest |
| location emitted for that file. */ |
| bool linemap_get_file_highest_location (class line_maps * set, |
| const char *file_name, |
| location_t *loc); |
| |
| /* Compute and return statistics about the memory consumption of some |
| parts of the line table SET. */ |
| void linemap_get_statistics (line_maps *, struct linemap_stats *); |
| |
| /* Dump debugging information about source location LOC into the file |
| stream STREAM. SET is the line map set LOC comes from. */ |
| void linemap_dump_location (line_maps *, location_t, FILE *); |
| |
| /* Dump line map at index IX in line table SET to STREAM. If STREAM |
| is NULL, use stderr. IS_MACRO is true if the caller wants to |
| dump a macro map, false otherwise. */ |
| void linemap_dump (FILE *, line_maps *, unsigned, bool); |
| |
| /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used. |
| NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO |
| specifies how many macro maps to dump. */ |
| void line_table_dump (FILE *, line_maps *, unsigned int, unsigned int); |
| |
| /* An enum for distinguishing the various parts within a location_t. */ |
| |
| enum location_aspect |
| { |
| LOCATION_ASPECT_CARET, |
| LOCATION_ASPECT_START, |
| LOCATION_ASPECT_FINISH |
| }; |
| |
| /* The rich_location class requires a way to expand location_t instances. |
| We would directly use expand_location_to_spelling_point, which is |
| implemented in gcc/input.c, but we also need to use it for rich_location |
| within genmatch.c. |
| Hence we require client code of libcpp to implement the following |
| symbol. */ |
| extern expanded_location |
| linemap_client_expand_location_to_spelling_point (location_t, |
| enum location_aspect); |
| |
| #endif /* !LIBCPP_LINE_MAP_H */ |