1/* Map (unsigned int) keys to (source file, line, column) triples. 2 Copyright (C) 2001-2020 Free Software Foundation, Inc. 3 4This program is free software; you can redistribute it and/or modify it 5under the terms of the GNU General Public License as published by the 6Free Software Foundation; either version 3, or (at your option) any 7later version. 8 9This program is distributed in the hope that it will be useful, 10but WITHOUT ANY WARRANTY; without even the implied warranty of 11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12GNU General Public License for more details. 13 14You should have received a copy of the GNU General Public License 15along with this program; see the file COPYING3. If not see 16<http://www.gnu.org/licenses/>. 17 18 In other words, you are welcome to use, share and improve this program. 19 You are forbidden to forbid anyone else to use, share and improve 20 what you give them. Help stamp out software-hoarding! */ 21 22#ifndef LIBCPP_LINE_MAP_H 23#define LIBCPP_LINE_MAP_H 24 25#ifndef GTY 26#define GTY(x) /* nothing */ 27#endif 28 29/* Both gcc and emacs number source *lines* starting at 1, but 30 they have differing conventions for *columns*. 31 32 GCC uses a 1-based convention for source columns, 33 whereas Emacs's M-x column-number-mode uses a 0-based convention. 34 35 For example, an error in the initial, left-hand 36 column of source line 3 is reported by GCC as: 37 38 some-file.c:3:1: error: ...etc... 39 40 On navigating to the location of that error in Emacs 41 (e.g. via "next-error"), 42 the locus is reported in the Mode Line 43 (assuming M-x column-number-mode) as: 44 45 some-file.c 10% (3, 0) 46 47 i.e. "3:1:" in GCC corresponds to "(3, 0)" in Emacs. */ 48 49/* The type of line numbers. */ 50typedef unsigned int linenum_type; 51 52/* A type for doing arithmetic on line numbers. */ 53typedef long long linenum_arith_t; 54 55/* A function for for use by qsort for comparing line numbers. */ 56 57inline int compare (linenum_type lhs, linenum_type rhs) 58{ 59 /* Avoid truncation issues by using linenum_arith_t for the comparison, 60 and only consider the sign of the result. */ 61 linenum_arith_t diff = (linenum_arith_t)lhs - (linenum_arith_t)rhs; 62 if (diff) 63 return diff > 0 ? 1 : -1; 64 return 0; 65} 66 67/* Reason for creating a new line map with linemap_add. */ 68enum lc_reason 69{ 70 LC_ENTER = 0, /* Begin #include. */ 71 LC_LEAVE, /* Return to including file. */ 72 LC_RENAME, /* Other reason for name change. */ 73 LC_RENAME_VERBATIM, /* Likewise, but "" != stdin. */ 74 LC_ENTER_MACRO, /* Begin macro expansion. */ 75 /* FIXME: add support for stringize and paste. */ 76 LC_HWM /* High Water Mark. */ 77}; 78 79/* The typedef "location_t" is a key within the location database, 80 identifying a source location or macro expansion, along with range 81 information, and (optionally) a pointer for use by gcc. 82 83 This key only has meaning in relation to a line_maps instance. Within 84 gcc there is a single line_maps instance: "line_table", declared in 85 gcc/input.h and defined in gcc/input.c. 86 87 The values of the keys are intended to be internal to libcpp, 88 but for ease-of-understanding the implementation, they are currently 89 assigned as follows: 90 91 Actual | Value | Meaning 92 -----------+-------------------------------+------------------------------- 93 0x00000000 | UNKNOWN_LOCATION (gcc/input.h)| Unknown/invalid location. 94 -----------+-------------------------------+------------------------------- 95 0x00000001 | BUILTINS_LOCATION | The location for declarations 96 | (gcc/input.h) | in "<built-in>" 97 -----------+-------------------------------+------------------------------- 98 0x00000002 | RESERVED_LOCATION_COUNT | The first location to be 99 | (also | handed out, and the 100 | ordmap[0]->start_location) | first line in ordmap 0 101 -----------+-------------------------------+------------------------------- 102 | ordmap[1]->start_location | First line in ordmap 1 103 | ordmap[1]->start_location+32 | First column in that line 104 | (assuming range_bits == 5) | 105 | ordmap[1]->start_location+64 | 2nd column in that line 106 | ordmap[1]->start_location+4096| Second line in ordmap 1 107 | (assuming column_bits == 12) 108 | 109 | Subsequent lines are offset by (1 << column_bits), 110 | e.g. 4096 for 12 bits, with a column value of 0 representing 111 | "the whole line". 112 | 113 | Within a line, the low "range_bits" (typically 5) are used for 114 | storing short ranges, so that there's an offset of 115 | (1 << range_bits) between individual columns within a line, 116 | typically 32. 117 | The low range_bits store the offset of the end point from the 118 | start point, and the start point is found by masking away 119 | the range bits. 120 | 121 | For example: 122 | ordmap[1]->start_location+64 "2nd column in that line" 123 | above means a caret at that location, with a range 124 | starting and finishing at the same place (the range bits 125 | are 0), a range of length 1. 126 | 127 | By contrast: 128 | ordmap[1]->start_location+68 129 | has range bits 0x4, meaning a caret with a range starting at 130 | that location, but with endpoint 4 columns further on: a range 131 | of length 5. 132 | 133 | Ranges that have caret != start, or have an endpoint too 134 | far away to fit in range_bits are instead stored as ad-hoc 135 | locations. Hence for range_bits == 5 we can compactly store 136 | tokens of length <= 32 without needing to use the ad-hoc 137 | table. 138 | 139 | This packing scheme means we effectively have 140 | (column_bits - range_bits) 141 | of bits for the columns, typically (12 - 5) = 7, for 128 142 | columns; longer line widths are accomodated by starting a 143 | new ordmap with a higher column_bits. 144 | 145 | ordmap[2]->start_location-1 | Final location in ordmap 1 146 -----------+-------------------------------+------------------------------- 147 | ordmap[2]->start_location | First line in ordmap 2 148 | ordmap[3]->start_location-1 | Final location in ordmap 2 149 -----------+-------------------------------+------------------------------- 150 | | (etc) 151 -----------+-------------------------------+------------------------------- 152 | ordmap[n-1]->start_location | First line in final ord map 153 | | (etc) 154 | set->highest_location - 1 | Final location in that ordmap 155 -----------+-------------------------------+------------------------------- 156 | set->highest_location | Location of the where the next 157 | | ordinary linemap would start 158 -----------+-------------------------------+------------------------------- 159 | | 160 | VVVVVVVVVVVVVVVVVVVVVVVVVVV 161 | Ordinary maps grow this way 162 | 163 | (unallocated integers) 164 | 165 0x60000000 | LINE_MAP_MAX_LOCATION_WITH_COLS 166 | Beyond this point, ordinary linemaps have 0 bits per column: 167 | each increment of the value corresponds to a new source line. 168 | 169 0x70000000 | LINE_MAP_MAX_LOCATION 170 | Beyond the point, we give up on ordinary maps; attempts to 171 | create locations in them lead to UNKNOWN_LOCATION (0). 172 | 173 | (unallocated integers) 174 | 175 | Macro maps grow this way 176 | ^^^^^^^^^^^^^^^^^^^^^^^^ 177 | | 178 -----------+-------------------------------+------------------------------- 179 | LINEMAPS_MACRO_LOWEST_LOCATION| Locations within macro maps 180 | macromap[m-1]->start_location | Start of last macro map 181 | | 182 -----------+-------------------------------+------------------------------- 183 | macromap[m-2]->start_location | Start of penultimate macro map 184 -----------+-------------------------------+------------------------------- 185 | macromap[1]->start_location | Start of macro map 1 186 -----------+-------------------------------+------------------------------- 187 | macromap[0]->start_location | Start of macro map 0 188 0x7fffffff | MAX_LOCATION_T | Also used as a mask for 189 | | accessing the ad-hoc data table 190 -----------+-------------------------------+------------------------------- 191 0x80000000 | Start of ad-hoc values; the lower 31 bits are used as an index 192 ... | into the line_table->location_adhoc_data_map.data array. 193 0xffffffff | UINT_MAX | 194 -----------+-------------------------------+------------------------------- 195 196 Examples of location encoding. 197 198 Packed ranges 199 ============= 200 201 Consider encoding the location of a token "foo", seen underlined here 202 on line 523, within an ordinary line_map that starts at line 500: 203 204 11111111112 205 12345678901234567890 206 522 207 523 return foo + bar; 208 ^~~ 209 524 210 211 The location's caret and start are both at line 523, column 11; the 212 location's finish is on the same line, at column 13 (an offset of 2 213 columns, for length 3). 214 215 Line 523 is offset 23 from the starting line of the ordinary line_map. 216 217 caret == start, and the offset of the finish fits within 5 bits, so 218 this can be stored as a packed range. 219 220 This is encoded as: 221 ordmap->start 222 + (line_offset << ordmap->m_column_and_range_bits) 223 + (column << ordmap->m_range_bits) 224 + (range_offset); 225 i.e. (for line offset 23, column 11, range offset 2): 226 ordmap->start 227 + (23 << 12) 228 + (11 << 5) 229 + 2; 230 i.e.: 231 ordmap->start + 0x17162 232 assuming that the line_map uses the default of 7 bits for columns and 233 5 bits for packed range (giving 12 bits for m_column_and_range_bits). 234 235 236 "Pure" locations 237 ================ 238 239 These are a special case of the above, where 240 caret == start == finish 241 They are stored as packed ranges with offset == 0. 242 For example, the location of the "f" of "foo" could be stored 243 as above, but with range offset 0, giving: 244 ordmap->start 245 + (23 << 12) 246 + (11 << 5) 247 + 0; 248 i.e.: 249 ordmap->start + 0x17160 250 251 252 Unoptimized ranges 253 ================== 254 255 Consider encoding the location of the binary expression 256 below: 257 258 11111111112 259 12345678901234567890 260 522 261 523 return foo + bar; 262 ~~~~^~~~~ 263 524 264 265 The location's caret is at the "+", line 523 column 15, but starts 266 earlier, at the "f" of "foo" at column 11. The finish is at the "r" 267 of "bar" at column 19. 268 269 This can't be stored as a packed range since start != caret. 270 Hence it is stored as an ad-hoc location e.g. 0x80000003. 271 272 Stripping off the top bit gives us an index into the ad-hoc 273 lookaside table: 274 275 line_table->location_adhoc_data_map.data[0x3] 276 277 from which the caret, start and finish can be looked up, 278 encoded as "pure" locations: 279 280 start == ordmap->start + (23 << 12) + (11 << 5) 281 == ordmap->start + 0x17160 (as above; the "f" of "foo") 282 283 caret == ordmap->start + (23 << 12) + (15 << 5) 284 == ordmap->start + 0x171e0 285 286 finish == ordmap->start + (23 << 12) + (19 << 5) 287 == ordmap->start + 0x17260 288 289 To further see how location_t works in practice, see the 290 worked example in libcpp/location-example.txt. */ 291typedef unsigned int location_t; 292 293/* Do not track column numbers higher than this one. As a result, the 294 range of column_bits is [12, 18] (or 0 if column numbers are 295 disabled). */ 296const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12); 297 298/* Do not pack ranges if locations get higher than this. 299 If you change this, update: 300 gcc.dg/plugin/location-overflow-test-*.c. */ 301const location_t LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000; 302 303/* Do not track column numbers if locations get higher than this. 304 If you change this, update: 305 gcc.dg/plugin/location-overflow-test-*.c. */ 306const location_t LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000; 307 308/* Highest possible source location encoded within an ordinary map. */ 309const location_t LINE_MAP_MAX_LOCATION = 0x70000000; 310 311/* A range of source locations. 312 313 Ranges are closed: 314 m_start is the first location within the range, 315 m_finish is the last location within the range. 316 317 We may need a more compact way to store these, but for now, 318 let's do it the simple way, as a pair. */ 319struct GTY(()) source_range 320{ 321 location_t m_start; 322 location_t m_finish; 323 324 /* We avoid using constructors, since various structs that 325 don't yet have constructors will embed instances of 326 source_range. */ 327 328 /* Make a source_range from a location_t. */ 329 static source_range from_location (location_t loc) 330 { 331 source_range result; 332 result.m_start = loc; 333 result.m_finish = loc; 334 return result; 335 } 336 337 /* Make a source_range from a pair of location_t. */ 338 static source_range from_locations (location_t start, 339 location_t finish) 340 { 341 source_range result; 342 result.m_start = start; 343 result.m_finish = finish; 344 return result; 345 } 346}; 347 348/* Memory allocation function typedef. Works like xrealloc. */ 349typedef void *(*line_map_realloc) (void *, size_t); 350 351/* Memory allocator function that returns the actual allocated size, 352 for a given requested allocation. */ 353typedef size_t (*line_map_round_alloc_size_func) (size_t); 354 355/* A line_map encodes a sequence of locations. 356 There are two kinds of maps. Ordinary maps and macro expansion 357 maps, a.k.a macro maps. 358 359 A macro map encodes source locations of tokens that are part of a 360 macro replacement-list, at a macro expansion point. E.g, in: 361 362 #define PLUS(A,B) A + B 363 364 No macro map is going to be created there, because we are not at a 365 macro expansion point. We are at a macro /definition/ point. So the 366 locations of the tokens of the macro replacement-list (i.e, A + B) 367 will be locations in an ordinary map, not a macro map. 368 369 On the other hand, if we later do: 370 371 int a = PLUS (1,2); 372 373 The invocation of PLUS here is a macro expansion. So we are at a 374 macro expansion point. The preprocessor expands PLUS (1,2) and 375 replaces it with the tokens of its replacement-list: 1 + 2. A macro 376 map is going to be created to hold (or rather to map, haha ...) the 377 locations of the tokens 1, + and 2. The macro map also records the 378 location of the expansion point of PLUS. That location is mapped in 379 the map that is active right before the location of the invocation 380 of PLUS. */ 381 382/* This contains GTY mark-up to support precompiled headers. 383 line_map is an abstract class, only derived objects exist. */ 384struct GTY((tag ("0"), desc ("MAP_ORDINARY_P (&%h) ? 1 : 2"))) line_map { 385 location_t start_location; 386 387 /* Size and alignment is (usually) 4 bytes. */ 388}; 389 390/* An ordinary line map encodes physical source locations. Those 391 physical source locations are called "spelling locations". 392 393 Physical source file TO_FILE at line TO_LINE at column 0 is represented 394 by the logical START_LOCATION. TO_LINE+L at column C is represented by 395 START_LOCATION+(L*(1<<m_column_and_range_bits))+(C*1<<m_range_bits), as 396 long as C<(1<<effective range bits), and the result_location is less than 397 the next line_map's start_location. 398 (The top line is line 1 and the leftmost column is column 1; line/column 0 399 means "entire file/line" or "unknown line/column" or "not applicable".) 400 401 The highest possible source location is MAX_LOCATION_T. */ 402struct GTY((tag ("1"))) line_map_ordinary : public line_map { 403 /* Base class is 4 bytes. */ 404 405 /* 4 bytes of integers, each 1 byte for easy extraction/insertion. */ 406 407 /* The reason for creation of this line map. */ 408 ENUM_BITFIELD (lc_reason) reason : 8; 409 410 /* SYSP is one for a system header, two for a C system header file 411 that therefore needs to be extern "C" protected in C++, and zero 412 otherwise. This field isn't really needed now that it's in 413 cpp_buffer. */ 414 unsigned char sysp; 415 416 /* Number of the low-order location_t bits used for column numbers 417 and ranges. */ 418 unsigned int m_column_and_range_bits : 8; 419 420 /* Number of the low-order "column" bits used for storing short ranges 421 inline, rather than in the ad-hoc table. 422 MSB LSB 423 31 0 424 +-------------------------+-------------------------------------------+ 425 | |<---map->column_and_range_bits (e.g. 12)-->| 426 +-------------------------+-----------------------+-------------------+ 427 | | column_and_range_bits | map->range_bits | 428 | | - range_bits | | 429 +-------------------------+-----------------------+-------------------+ 430 | row bits | effective column bits | short range bits | 431 | | (e.g. 7) | (e.g. 5) | 432 +-------------------------+-----------------------+-------------------+ */ 433 unsigned int m_range_bits : 8; 434 435 /* Pointer alignment boundary on both 32 and 64-bit systems. */ 436 437 const char *to_file; 438 linenum_type to_line; 439 440 /* Location from whence this line map was included. For regular 441 #includes, this location will be the last location of a map. For 442 outermost file, this is 0. */ 443 location_t included_from; 444 445 /* Size is 20 or 24 bytes, no padding */ 446}; 447 448/* This is the highest possible source location encoded within an 449 ordinary or macro map. */ 450const location_t MAX_LOCATION_T = 0x7FFFFFFF; 451 452struct cpp_hashnode; 453 454/* A macro line map encodes location of tokens coming from a macro 455 expansion. 456 457 The offset from START_LOCATION is used to index into 458 MACRO_LOCATIONS; this holds the original location of the token. */ 459struct GTY((tag ("2"))) line_map_macro : public line_map { 460 /* Base is 4 bytes. */ 461 462 /* The number of tokens inside the replacement-list of MACRO. */ 463 unsigned int n_tokens; 464 465 /* Pointer alignment boundary. */ 466 467 /* The cpp macro whose expansion gave birth to this macro map. */ 468 struct cpp_hashnode * 469 GTY ((nested_ptr (union tree_node, 470 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL", 471 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"))) 472 macro; 473 474 /* This array of location is actually an array of pairs of 475 locations. The elements inside it thus look like: 476 477 x0,y0, x1,y1, x2,y2, ...., xn,yn. 478 479 where n == n_tokens; 480 481 Remember that these xI,yI are collected when libcpp is about to 482 expand a given macro. 483 484 yI is the location in the macro definition, either of the token 485 itself or of a macro parameter that it replaces. 486 487 Imagine this: 488 489 #define PLUS(A, B) A + B <--- #1 490 491 int a = PLUS (1,2); <--- #2 492 493 There is a macro map for the expansion of PLUS in #2. PLUS is 494 expanded into its expansion-list. The expansion-list is the 495 replacement-list of PLUS where the macro parameters are replaced 496 with their arguments. So the replacement-list of PLUS is made of 497 the tokens: 498 499 A, +, B 500 501 and the expansion-list is made of the tokens: 502 503 1, +, 2 504 505 Let's consider the case of token "+". Its y1 [yI for I == 1] is 506 its spelling location in #1. 507 508 y0 (thus for token "1") is the spelling location of A in #1. 509 510 And y2 (of token "2") is the spelling location of B in #1. 511 512 When the token is /not/ an argument for a macro, xI is the same 513 location as yI. Otherwise, xI is the location of the token 514 outside this macro expansion. If this macro was expanded from 515 another macro expansion, xI is a virtual location representing 516 the token in that macro expansion; otherwise, it is the spelling 517 location of the token. 518 519 Note that a virtual location is a location returned by 520 linemap_add_macro_token. It encodes the relevant locations (x,y 521 pairs) of that token across the macro expansions from which it 522 (the token) might come from. 523 524 In the example above x1 (for token "+") is going to be the same 525 as y1. x0 is the spelling location for the argument token "1", 526 and x2 is the spelling location for the argument token "2". */ 527 location_t * GTY((atomic)) macro_locations; 528 529 /* This is the location of the expansion point of the current macro 530 map. It's the location of the macro name. That location is held 531 by the map that was current right before the current one. It 532 could have been either a macro or an ordinary map, depending on 533 if we are in a nested expansion context not. */ 534 location_t expansion; 535 536 /* Size is 20 or 32 (4 bytes padding on 64-bit). */ 537}; 538 539#if CHECKING_P && (GCC_VERSION >= 2007) 540 541/* Assertion macro to be used in line-map code. */ 542#define linemap_assert(EXPR) \ 543 do { \ 544 if (! (EXPR)) \ 545 abort (); \ 546 } while (0) 547 548/* Assert that becomes a conditional expression when checking is disabled at 549 compilation time. Use this for conditions that should not happen but if 550 they happen, it is better to handle them gracefully rather than crash 551 randomly later. 552 Usage: 553 554 if (linemap_assert_fails(EXPR)) handle_error(); */ 555#define linemap_assert_fails(EXPR) __extension__ \ 556 ({linemap_assert (EXPR); false;}) 557 558#else 559/* Include EXPR, so that unused variable warnings do not occur. */ 560#define linemap_assert(EXPR) ((void)(0 && (EXPR))) 561#define linemap_assert_fails(EXPR) (! (EXPR)) 562#endif 563 564/* Get whether location LOC is an ordinary location. */ 565 566inline bool 567IS_ORDINARY_LOC (location_t loc) 568{ 569 return loc < LINE_MAP_MAX_LOCATION; 570} 571 572/* Get whether location LOC is an ad-hoc location. */ 573 574inline bool 575IS_ADHOC_LOC (location_t loc) 576{ 577 return loc > MAX_LOCATION_T; 578} 579 580/* Categorize line map kinds. */ 581 582inline bool 583MAP_ORDINARY_P (const line_map *map) 584{ 585 return IS_ORDINARY_LOC (map->start_location); 586} 587 588/* Return TRUE if MAP encodes locations coming from a macro 589 replacement-list at macro expansion point. */ 590bool 591linemap_macro_expansion_map_p (const line_map *); 592 593/* Assert that MAP encodes locations of tokens that are not part of 594 the replacement-list of a macro expansion, downcasting from 595 line_map * to line_map_ordinary *. */ 596 597inline line_map_ordinary * 598linemap_check_ordinary (line_map *map) 599{ 600 linemap_assert (MAP_ORDINARY_P (map)); 601 return (line_map_ordinary *)map; 602} 603 604/* Assert that MAP encodes locations of tokens that are not part of 605 the replacement-list of a macro expansion, downcasting from 606 const line_map * to const line_map_ordinary *. */ 607 608inline const line_map_ordinary * 609linemap_check_ordinary (const line_map *map) 610{ 611 linemap_assert (MAP_ORDINARY_P (map)); 612 return (const line_map_ordinary *)map; 613} 614 615/* Assert that MAP is a macro expansion and downcast to the appropriate 616 subclass. */ 617 618inline line_map_macro *linemap_check_macro (line_map *map) 619{ 620 linemap_assert (!MAP_ORDINARY_P (map)); 621 return (line_map_macro *)map; 622} 623 624/* Assert that MAP is a macro expansion and downcast to the appropriate 625 subclass. */ 626 627inline const line_map_macro * 628linemap_check_macro (const line_map *map) 629{ 630 linemap_assert (!MAP_ORDINARY_P (map)); 631 return (const line_map_macro *)map; 632} 633 634/* Read the start location of MAP. */ 635 636inline location_t 637MAP_START_LOCATION (const line_map *map) 638{ 639 return map->start_location; 640} 641 642/* Get the starting line number of ordinary map MAP. */ 643 644inline linenum_type 645ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map) 646{ 647 return ord_map->to_line; 648} 649 650/* Return a positive value if map encodes locations from a system 651 header, 0 otherwise. Returns 1 if ordinary map MAP encodes locations 652 in a system header and 2 if it encodes locations in a C system header 653 that therefore needs to be extern "C" protected in C++. */ 654 655inline unsigned char 656ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map) 657{ 658 return ord_map->sysp; 659} 660 661/* Get the filename of ordinary map MAP. */ 662 663inline const char * 664ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map) 665{ 666 return ord_map->to_file; 667} 668 669/* Get the cpp macro whose expansion gave birth to macro map MAP. */ 670 671inline cpp_hashnode * 672MACRO_MAP_MACRO (const line_map_macro *macro_map) 673{ 674 return macro_map->macro; 675} 676 677/* Get the number of tokens inside the replacement-list of the macro 678 that led to macro map MAP. */ 679 680inline unsigned int 681MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map) 682{ 683 return macro_map->n_tokens; 684} 685 686/* Get the array of pairs of locations within macro map MAP. 687 See the declaration of line_map_macro for more information. */ 688 689inline location_t * 690MACRO_MAP_LOCATIONS (const line_map_macro *macro_map) 691{ 692 return macro_map->macro_locations; 693} 694 695/* Get the location of the expansion point of the macro map MAP. */ 696 697inline location_t 698MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro *macro_map) 699{ 700 return macro_map->expansion; 701} 702 703/* The abstraction of a set of location maps. There can be several 704 types of location maps. This abstraction contains the attributes 705 that are independent from the type of the map. 706 707 Essentially this is just a vector of T_linemap_subclass, 708 which can only ever grow in size. */ 709 710struct GTY(()) maps_info_ordinary { 711 /* This array contains the "ordinary" line maps, for all 712 events other than macro expansion 713 (e.g. when a new preprocessing unit starts or ends). */ 714 line_map_ordinary * GTY ((length ("%h.used"))) maps; 715 716 /* The total number of allocated maps. */ 717 unsigned int allocated; 718 719 /* The number of elements used in maps. This number is smaller 720 or equal to ALLOCATED. */ 721 unsigned int used; 722 723 mutable unsigned int cache; 724}; 725 726struct GTY(()) maps_info_macro { 727 /* This array contains the macro line maps. 728 A macro line map is created whenever a macro expansion occurs. */ 729 line_map_macro * GTY ((length ("%h.used"))) maps; 730 731 /* The total number of allocated maps. */ 732 unsigned int allocated; 733 734 /* The number of elements used in maps. This number is smaller 735 or equal to ALLOCATED. */ 736 unsigned int used; 737 738 mutable unsigned int cache; 739}; 740 741/* Data structure to associate a source_range together with an arbitrary 742 data pointer with a source location. */ 743struct GTY(()) location_adhoc_data { 744 location_t locus; 745 source_range src_range; 746 void * GTY((skip)) data; 747}; 748 749struct htab; 750 751/* The following data structure encodes a location with some adhoc data 752 and maps it to a new unsigned integer (called an adhoc location) 753 that replaces the original location to represent the mapping. 754 755 The new adhoc_loc uses the highest bit as the enabling bit, i.e. if the 756 highest bit is 1, then the number is adhoc_loc. Otherwise, it serves as 757 the original location. Once identified as the adhoc_loc, the lower 31 758 bits of the integer is used to index the location_adhoc_data array, 759 in which the locus and associated data is stored. */ 760 761struct GTY(()) location_adhoc_data_map { 762 struct htab * GTY((skip)) htab; 763 location_t curr_loc; 764 unsigned int allocated; 765 struct location_adhoc_data GTY((length ("%h.allocated"))) *data; 766}; 767 768/* A set of chronological line_map structures. */ 769class GTY(()) line_maps { 770public: 771 772 ~line_maps (); 773 774 maps_info_ordinary info_ordinary; 775 776 maps_info_macro info_macro; 777 778 /* Depth of the include stack, including the current file. */ 779 unsigned int depth; 780 781 /* If true, prints an include trace a la -H. */ 782 bool trace_includes; 783 784 /* Highest location_t "given out". */ 785 location_t highest_location; 786 787 /* Start of line of highest location_t "given out". */ 788 location_t highest_line; 789 790 /* The maximum column number we can quickly allocate. Higher numbers 791 may require allocating a new line_map. */ 792 unsigned int max_column_hint; 793 794 /* The allocator to use when resizing 'maps', defaults to xrealloc. */ 795 line_map_realloc reallocator; 796 797 /* The allocators' function used to know the actual size it 798 allocated, for a certain allocation size requested. */ 799 line_map_round_alloc_size_func round_alloc_size; 800 801 struct location_adhoc_data_map location_adhoc_data_map; 802 803 /* The special location value that is used as spelling location for 804 built-in tokens. */ 805 location_t builtin_location; 806 807 /* True if we've seen a #line or # 44 "file" directive. */ 808 bool seen_line_directive; 809 810 /* The default value of range_bits in ordinary line maps. */ 811 unsigned int default_range_bits; 812 813 unsigned int num_optimized_ranges; 814 unsigned int num_unoptimized_ranges; 815}; 816 817/* Returns the number of allocated maps so far. MAP_KIND shall be TRUE 818 if we are interested in macro maps, FALSE otherwise. */ 819inline unsigned int 820LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind) 821{ 822 if (map_kind) 823 return set->info_macro.allocated; 824 else 825 return set->info_ordinary.allocated; 826} 827 828/* As above, but by reference (e.g. as an lvalue). */ 829 830inline unsigned int & 831LINEMAPS_ALLOCATED (line_maps *set, bool map_kind) 832{ 833 if (map_kind) 834 return set->info_macro.allocated; 835 else 836 return set->info_ordinary.allocated; 837} 838 839/* Returns the number of used maps so far. MAP_KIND shall be TRUE if 840 we are interested in macro maps, FALSE otherwise.*/ 841inline unsigned int 842LINEMAPS_USED (const line_maps *set, bool map_kind) 843{ 844 if (map_kind) 845 return set->info_macro.used; 846 else 847 return set->info_ordinary.used; 848} 849 850/* As above, but by reference (e.g. as an lvalue). */ 851 852inline unsigned int & 853LINEMAPS_USED (line_maps *set, bool map_kind) 854{ 855 if (map_kind) 856 return set->info_macro.used; 857 else 858 return set->info_ordinary.used; 859} 860 861/* Returns the index of the last map that was looked up with 862 linemap_lookup. MAP_KIND shall be TRUE if we are interested in 863 macro maps, FALSE otherwise. */ 864inline unsigned int & 865LINEMAPS_CACHE (const line_maps *set, bool map_kind) 866{ 867 if (map_kind) 868 return set->info_macro.cache; 869 else 870 return set->info_ordinary.cache; 871} 872 873/* Return the map at a given index. */ 874inline line_map * 875LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int index) 876{ 877 if (map_kind) 878 return &set->info_macro.maps[index]; 879 else 880 return &set->info_ordinary.maps[index]; 881} 882 883/* Returns the last map used in the line table SET. MAP_KIND 884 shall be TRUE if we are interested in macro maps, FALSE 885 otherwise.*/ 886inline line_map * 887LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind) 888{ 889 return LINEMAPS_MAP_AT (set, map_kind, 890 LINEMAPS_USED (set, map_kind) - 1); 891} 892 893/* Returns the last map that was allocated in the line table SET. 894 MAP_KIND shall be TRUE if we are interested in macro maps, FALSE 895 otherwise.*/ 896inline line_map * 897LINEMAPS_LAST_ALLOCATED_MAP (const line_maps *set, bool map_kind) 898{ 899 return LINEMAPS_MAP_AT (set, map_kind, 900 LINEMAPS_ALLOCATED (set, map_kind) - 1); 901} 902 903/* Returns a pointer to the memory region where ordinary maps are 904 allocated in the line table SET. */ 905inline line_map_ordinary * 906LINEMAPS_ORDINARY_MAPS (const line_maps *set) 907{ 908 return set->info_ordinary.maps; 909} 910 911/* Returns the INDEXth ordinary map. */ 912inline line_map_ordinary * 913LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index) 914{ 915 linemap_assert (index >= 0 916 && (unsigned int)index < LINEMAPS_USED (set, false)); 917 return (line_map_ordinary *)LINEMAPS_MAP_AT (set, false, index); 918} 919 920/* Return the number of ordinary maps allocated in the line table 921 SET. */ 922inline unsigned int 923LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set) 924{ 925 return LINEMAPS_ALLOCATED (set, false); 926} 927 928/* Return the number of ordinary maps used in the line table SET. */ 929inline unsigned int 930LINEMAPS_ORDINARY_USED (const line_maps *set) 931{ 932 return LINEMAPS_USED (set, false); 933} 934 935/* Return the index of the last ordinary map that was looked up with 936 linemap_lookup. */ 937inline unsigned int & 938LINEMAPS_ORDINARY_CACHE (const line_maps *set) 939{ 940 return LINEMAPS_CACHE (set, false); 941} 942 943/* Returns a pointer to the last ordinary map used in the line table 944 SET. */ 945inline line_map_ordinary * 946LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set) 947{ 948 return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, false); 949} 950 951/* Returns a pointer to the last ordinary map allocated the line table 952 SET. */ 953inline line_map_ordinary * 954LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps *set) 955{ 956 return (line_map_ordinary *)LINEMAPS_LAST_ALLOCATED_MAP (set, false); 957} 958 959/* Returns a pointer to the beginning of the region where macro maps 960 are allocated. */ 961inline line_map_macro * 962LINEMAPS_MACRO_MAPS (const line_maps *set) 963{ 964 return set->info_macro.maps; 965} 966 967/* Returns the INDEXth macro map. */ 968inline line_map_macro * 969LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index) 970{ 971 linemap_assert (index >= 0 972 && (unsigned int)index < LINEMAPS_USED (set, true)); 973 return (line_map_macro *)LINEMAPS_MAP_AT (set, true, index); 974} 975 976/* Returns the number of macro maps that were allocated in the line 977 table SET. */ 978inline unsigned int 979LINEMAPS_MACRO_ALLOCATED (const line_maps *set) 980{ 981 return LINEMAPS_ALLOCATED (set, true); 982} 983 984/* Returns the number of macro maps used in the line table SET. */ 985inline unsigned int 986LINEMAPS_MACRO_USED (const line_maps *set) 987{ 988 return LINEMAPS_USED (set, true); 989} 990 991/* Return the index of the last macro map that was looked up with 992 linemap_lookup. */ 993inline unsigned int & 994LINEMAPS_MACRO_CACHE (const line_maps *set) 995{ 996 return LINEMAPS_CACHE (set, true); 997} 998 999/* Returns the last macro map used in the line table SET. */ 1000inline line_map_macro * 1001LINEMAPS_LAST_MACRO_MAP (const line_maps *set) 1002{ 1003 return (line_map_macro *)LINEMAPS_LAST_MAP (set, true); 1004} 1005 1006/* Returns the lowest location [of a token resulting from macro 1007 expansion] encoded in this line table. */ 1008inline location_t 1009LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set) 1010{ 1011 return LINEMAPS_MACRO_USED (set) 1012 ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set)) 1013 : MAX_LOCATION_T + 1; 1014} 1015 1016/* Returns the last macro map allocated in the line table SET. */ 1017inline line_map_macro * 1018LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set) 1019{ 1020 return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true); 1021} 1022 1023extern location_t get_combined_adhoc_loc (class line_maps *, 1024 location_t, 1025 source_range, 1026 void *); 1027extern void *get_data_from_adhoc_loc (const line_maps *, location_t); 1028extern location_t get_location_from_adhoc_loc (const line_maps *, 1029 location_t); 1030 1031extern source_range get_range_from_loc (line_maps *set, location_t loc); 1032 1033/* Get whether location LOC is a "pure" location, or 1034 whether it is an ad-hoc location, or embeds range information. */ 1035 1036bool 1037pure_location_p (line_maps *set, location_t loc); 1038 1039/* Given location LOC within SET, strip away any packed range information 1040 or ad-hoc information. */ 1041 1042extern location_t get_pure_location (line_maps *set, 1043 location_t loc); 1044 1045/* Combine LOC and BLOCK, giving a combined adhoc location. */ 1046 1047inline location_t 1048COMBINE_LOCATION_DATA (class line_maps *set, 1049 location_t loc, 1050 source_range src_range, 1051 void *block) 1052{ 1053 return get_combined_adhoc_loc (set, loc, src_range, block); 1054} 1055 1056extern void rebuild_location_adhoc_htab (class line_maps *); 1057 1058/* Initialize a line map set. SET is the line map set to initialize 1059 and BUILTIN_LOCATION is the special location value to be used as 1060 spelling location for built-in tokens. This BUILTIN_LOCATION has 1061 to be strictly less than RESERVED_LOCATION_COUNT. */ 1062extern void linemap_init (class line_maps *set, 1063 location_t builtin_location); 1064 1065/* Check for and warn about line_maps entered but not exited. */ 1066 1067extern void linemap_check_files_exited (class line_maps *); 1068 1069/* Return a location_t for the start (i.e. column==0) of 1070 (physical) line TO_LINE in the current source file (as in the 1071 most recent linemap_add). MAX_COLUMN_HINT is the highest column 1072 number we expect to use in this line (but it does not change 1073 the highest_location). */ 1074 1075extern location_t linemap_line_start 1076(class line_maps *set, linenum_type to_line, unsigned int max_column_hint); 1077 1078/* Add a mapping of logical source line to physical source file and 1079 line number. This function creates an "ordinary map", which is a 1080 map that records locations of tokens that are not part of macro 1081 replacement-lists present at a macro expansion point. 1082 1083 The text pointed to by TO_FILE must have a lifetime 1084 at least as long as the lifetime of SET. An empty 1085 TO_FILE means standard input. If reason is LC_LEAVE, and 1086 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their 1087 natural values considering the file we are returning to. 1088 1089 A call to this function can relocate the previous set of 1090 maps, so any stored line_map pointers should not be used. */ 1091extern const line_map *linemap_add 1092 (class line_maps *, enum lc_reason, unsigned int sysp, 1093 const char *to_file, linenum_type to_line); 1094 1095/* Given a logical source location, returns the map which the 1096 corresponding (source file, line, column) triplet can be deduced 1097 from. Since the set is built chronologically, the logical lines are 1098 monotonic increasing, and so the list is sorted and we can use a 1099 binary search. If no line map have been allocated yet, this 1100 function returns NULL. */ 1101extern const line_map *linemap_lookup 1102 (const line_maps *, location_t); 1103 1104/* Returns TRUE if the line table set tracks token locations across 1105 macro expansion, FALSE otherwise. */ 1106bool linemap_tracks_macro_expansion_locs_p (class line_maps *); 1107 1108/* Return the name of the macro associated to MACRO_MAP. */ 1109const char* linemap_map_get_macro_name (const line_map_macro *); 1110 1111/* Return a positive value if LOCATION is the locus of a token that is 1112 located in a system header, O otherwise. It returns 1 if LOCATION 1113 is the locus of a token that is located in a system header, and 2 1114 if LOCATION is the locus of a token located in a C system header 1115 that therefore needs to be extern "C" protected in C++. 1116 1117 Note that this function returns 1 if LOCATION belongs to a token 1118 that is part of a macro replacement-list defined in a system 1119 header, but expanded in a non-system file. */ 1120int linemap_location_in_system_header_p (class line_maps *, 1121 location_t); 1122 1123/* Return TRUE if LOCATION is a source code location of a token that is part of 1124 a macro expansion, FALSE otherwise. */ 1125bool linemap_location_from_macro_expansion_p (const line_maps *, 1126 location_t); 1127 1128/* TRUE if LOCATION is a source code location of a token that is part of the 1129 definition of a macro, FALSE otherwise. */ 1130bool linemap_location_from_macro_definition_p (class line_maps *, 1131 location_t); 1132 1133/* With the precondition that LOCATION is the locus of a token that is 1134 an argument of a function-like macro MACRO_MAP and appears in the 1135 expansion of MACRO_MAP, return the locus of that argument in the 1136 context of the caller of MACRO_MAP. */ 1137 1138extern location_t linemap_macro_map_loc_unwind_toward_spelling 1139 (line_maps *set, const line_map_macro *macro_map, location_t location); 1140 1141/* location_t values from 0 to RESERVED_LOCATION_COUNT-1 will 1142 be reserved for libcpp user as special values, no token from libcpp 1143 will contain any of those locations. */ 1144const location_t RESERVED_LOCATION_COUNT = 2; 1145 1146/* Converts a map and a location_t to source line. */ 1147inline linenum_type 1148SOURCE_LINE (const line_map_ordinary *ord_map, location_t loc) 1149{ 1150 return ((loc - ord_map->start_location) 1151 >> ord_map->m_column_and_range_bits) + ord_map->to_line; 1152} 1153 1154/* Convert a map and location_t to source column number. */ 1155inline linenum_type 1156SOURCE_COLUMN (const line_map_ordinary *ord_map, location_t loc) 1157{ 1158 return ((loc - ord_map->start_location) 1159 & ((1 << ord_map->m_column_and_range_bits) - 1)) >> ord_map->m_range_bits; 1160} 1161 1162 1163inline location_t 1164linemap_included_from (const line_map_ordinary *ord_map) 1165{ 1166 return ord_map->included_from; 1167} 1168 1169/* The linemap containing the included-from location of MAP. */ 1170const line_map_ordinary *linemap_included_from_linemap 1171 (line_maps *set, const line_map_ordinary *map); 1172 1173/* True if the map is at the bottom of the include stack. */ 1174 1175inline bool 1176MAIN_FILE_P (const line_map_ordinary *ord_map) 1177{ 1178 return ord_map->included_from == 0; 1179} 1180 1181/* Encode and return a location_t from a column number. The 1182 source line considered is the last source line used to call 1183 linemap_line_start, i.e, the last source line which a location was 1184 encoded from. */ 1185extern location_t 1186linemap_position_for_column (class line_maps *, unsigned int); 1187 1188/* Encode and return a source location from a given line and 1189 column. */ 1190location_t 1191linemap_position_for_line_and_column (line_maps *set, 1192 const line_map_ordinary *, 1193 linenum_type, unsigned int); 1194 1195/* Encode and return a location_t starting from location LOC and 1196 shifting it by OFFSET columns. This function does not support 1197 virtual locations. */ 1198location_t 1199linemap_position_for_loc_and_offset (class line_maps *set, 1200 location_t loc, 1201 unsigned int offset); 1202 1203/* Return the file this map is for. */ 1204inline const char * 1205LINEMAP_FILE (const line_map_ordinary *ord_map) 1206{ 1207 return ord_map->to_file; 1208} 1209 1210/* Return the line number this map started encoding location from. */ 1211inline linenum_type 1212LINEMAP_LINE (const line_map_ordinary *ord_map) 1213{ 1214 return ord_map->to_line; 1215} 1216 1217/* Return a positive value if map encodes locations from a system 1218 header, 0 otherwise. Returns 1 if MAP encodes locations in a 1219 system header and 2 if it encodes locations in a C system header 1220 that therefore needs to be extern "C" protected in C++. */ 1221inline unsigned char 1222LINEMAP_SYSP (const line_map_ordinary *ord_map) 1223{ 1224 return ord_map->sysp; 1225} 1226 1227/* Return a positive value if PRE denotes the location of a token that 1228 comes before the token of POST, 0 if PRE denotes the location of 1229 the same token as the token for POST, and a negative value 1230 otherwise. */ 1231int linemap_compare_locations (class line_maps *set, 1232 location_t pre, 1233 location_t post); 1234 1235/* Return TRUE if LOC_A denotes the location a token that comes 1236 topogically before the token denoted by location LOC_B, or if they 1237 are equal. */ 1238inline bool 1239linemap_location_before_p (class line_maps *set, 1240 location_t loc_a, 1241 location_t loc_b) 1242{ 1243 return linemap_compare_locations (set, loc_a, loc_b) >= 0; 1244} 1245 1246typedef struct 1247{ 1248 /* The name of the source file involved. */ 1249 const char *file; 1250 1251 /* The line-location in the source file. */ 1252 int line; 1253 1254 int column; 1255 1256 void *data; 1257 1258 /* In a system header?. */ 1259 bool sysp; 1260} expanded_location; 1261 1262class range_label; 1263 1264/* A hint to diagnostic_show_locus on how to print a source range within a 1265 rich_location. 1266 1267 Typically this is SHOW_RANGE_WITH_CARET for the 0th range, and 1268 SHOW_RANGE_WITHOUT_CARET for subsequent ranges, 1269 but the Fortran frontend uses SHOW_RANGE_WITH_CARET repeatedly for 1270 printing things like: 1271 1272 x = x + y 1273 1 2 1274 Error: Shapes for operands at (1) and (2) are not conformable 1275 1276 where "1" and "2" are notionally carets. */ 1277 1278enum range_display_kind 1279{ 1280 /* Show the pertinent source line(s), the caret, and underline(s). */ 1281 SHOW_RANGE_WITH_CARET, 1282 1283 /* Show the pertinent source line(s) and underline(s), but don't 1284 show the caret (just an underline). */ 1285 SHOW_RANGE_WITHOUT_CARET, 1286 1287 /* Just show the source lines; don't show the range itself. 1288 This is for use when displaying some line-insertion fix-it hints (for 1289 showing the user context on the change, for when it doesn't make sense 1290 to highlight the first column on the next line). */ 1291 SHOW_LINES_WITHOUT_RANGE 1292}; 1293 1294/* A location within a rich_location: a caret&range, with 1295 the caret potentially flagged for display, and an optional 1296 label. */ 1297 1298struct location_range 1299{ 1300 location_t m_loc; 1301 1302 enum range_display_kind m_range_display_kind; 1303 1304 /* If non-NULL, the label for this range. */ 1305 const range_label *m_label; 1306}; 1307 1308/* A partially-embedded vec for use within rich_location for storing 1309 ranges and fix-it hints. 1310 1311 Elements [0..NUM_EMBEDDED) are allocated within m_embed, after 1312 that they are within the dynamically-allocated m_extra. 1313 1314 This allows for static allocation in the common case, whilst 1315 supporting the rarer case of an arbitrary number of elements. 1316 1317 Dynamic allocation is not performed unless it's needed. */ 1318 1319template <typename T, int NUM_EMBEDDED> 1320class semi_embedded_vec 1321{ 1322 public: 1323 semi_embedded_vec (); 1324 ~semi_embedded_vec (); 1325 1326 unsigned int count () const { return m_num; } 1327 T& operator[] (int idx); 1328 const T& operator[] (int idx) const; 1329 1330 void push (const T&); 1331 void truncate (int len); 1332 1333 private: 1334 int m_num; 1335 T m_embedded[NUM_EMBEDDED]; 1336 int m_alloc; 1337 T *m_extra; 1338}; 1339 1340/* Constructor for semi_embedded_vec. In particular, no dynamic allocation 1341 is done. */ 1342 1343template <typename T, int NUM_EMBEDDED> 1344semi_embedded_vec<T, NUM_EMBEDDED>::semi_embedded_vec () 1345: m_num (0), m_alloc (0), m_extra (NULL) 1346{ 1347} 1348 1349/* semi_embedded_vec's dtor. Release any dynamically-allocated memory. */ 1350 1351template <typename T, int NUM_EMBEDDED> 1352semi_embedded_vec<T, NUM_EMBEDDED>::~semi_embedded_vec () 1353{ 1354 XDELETEVEC (m_extra); 1355} 1356 1357/* Look up element IDX, mutably. */ 1358 1359template <typename T, int NUM_EMBEDDED> 1360T& 1361semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) 1362{ 1363 linemap_assert (idx < m_num); 1364 if (idx < NUM_EMBEDDED) 1365 return m_embedded[idx]; 1366 else 1367 { 1368 linemap_assert (m_extra != NULL); 1369 return m_extra[idx - NUM_EMBEDDED]; 1370 } 1371} 1372 1373/* Look up element IDX (const). */ 1374 1375template <typename T, int NUM_EMBEDDED> 1376const T& 1377semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) const 1378{ 1379 linemap_assert (idx < m_num); 1380 if (idx < NUM_EMBEDDED) 1381 return m_embedded[idx]; 1382 else 1383 { 1384 linemap_assert (m_extra != NULL); 1385 return m_extra[idx - NUM_EMBEDDED]; 1386 } 1387} 1388 1389/* Append VALUE to the end of the semi_embedded_vec. */ 1390 1391template <typename T, int NUM_EMBEDDED> 1392void 1393semi_embedded_vec<T, NUM_EMBEDDED>::push (const T& value) 1394{ 1395 int idx = m_num++; 1396 if (idx < NUM_EMBEDDED) 1397 m_embedded[idx] = value; 1398 else 1399 { 1400 /* Offset "idx" to be an index within m_extra. */ 1401 idx -= NUM_EMBEDDED; 1402 if (NULL == m_extra) 1403 { 1404 linemap_assert (m_alloc == 0); 1405 m_alloc = 16; 1406 m_extra = XNEWVEC (T, m_alloc); 1407 } 1408 else if (idx >= m_alloc) 1409 { 1410 linemap_assert (m_alloc > 0); 1411 m_alloc *= 2; 1412 m_extra = XRESIZEVEC (T, m_extra, m_alloc); 1413 } 1414 linemap_assert (m_extra); 1415 linemap_assert (idx < m_alloc); 1416 m_extra[idx] = value; 1417 } 1418} 1419 1420/* Truncate to length LEN. No deallocation is performed. */ 1421 1422template <typename T, int NUM_EMBEDDED> 1423void 1424semi_embedded_vec<T, NUM_EMBEDDED>::truncate (int len) 1425{ 1426 linemap_assert (len <= m_num); 1427 m_num = len; 1428} 1429 1430class fixit_hint; 1431class diagnostic_path; 1432 1433/* A "rich" source code location, for use when printing diagnostics. 1434 A rich_location has one or more carets&ranges, where the carets 1435 are optional. These are referred to as "ranges" from here. 1436 Typically the zeroth range has a caret; other ranges sometimes 1437 have carets. 1438 1439 The "primary" location of a rich_location is the caret of range 0, 1440 used for determining the line/column when printing diagnostic 1441 text, such as: 1442 1443 some-file.c:3:1: error: ...etc... 1444 1445 Additional ranges may be added to help the user identify other 1446 pertinent clauses in a diagnostic. 1447 1448 Ranges can (optionally) be given labels via class range_label. 1449 1450 rich_location instances are intended to be allocated on the stack 1451 when generating diagnostics, and to be short-lived. 1452 1453 Examples of rich locations 1454 -------------------------- 1455 1456 Example A 1457 ********* 1458 int i = "foo"; 1459 ^ 1460 This "rich" location is simply a single range (range 0), with 1461 caret = start = finish at the given point. 1462 1463 Example B 1464 ********* 1465 a = (foo && bar) 1466 ~~~~~^~~~~~~ 1467 This rich location has a single range (range 0), with the caret 1468 at the first "&", and the start/finish at the parentheses. 1469 Compare with example C below. 1470 1471 Example C 1472 ********* 1473 a = (foo && bar) 1474 ~~~ ^~ ~~~ 1475 This rich location has three ranges: 1476 - Range 0 has its caret and start location at the first "&" and 1477 end at the second "&. 1478 - Range 1 has its start and finish at the "f" and "o" of "foo"; 1479 the caret is not flagged for display, but is perhaps at the "f" 1480 of "foo". 1481 - Similarly, range 2 has its start and finish at the "b" and "r" of 1482 "bar"; the caret is not flagged for display, but is perhaps at the 1483 "b" of "bar". 1484 Compare with example B above. 1485 1486 Example D (Fortran frontend) 1487 **************************** 1488 x = x + y 1489 1 2 1490 This rich location has range 0 at "1", and range 1 at "2". 1491 Both are flagged for caret display. Both ranges have start/finish 1492 equal to their caret point. The frontend overrides the diagnostic 1493 context's default caret character for these ranges. 1494 1495 Example E (range labels) 1496 ************************ 1497 printf ("arg0: %i arg1: %s arg2: %i", 1498 ^~ 1499 | 1500 const char * 1501 100, 101, 102); 1502 ~~~ 1503 | 1504 int 1505 This rich location has two ranges: 1506 - range 0 is at the "%s" with start = caret = "%" and finish at 1507 the "s". It has a range_label ("const char *"). 1508 - range 1 has start/finish covering the "101" and is not flagged for 1509 caret printing. The caret is at the start of "101", where its 1510 range_label is printed ("int"). 1511 1512 Fix-it hints 1513 ------------ 1514 1515 Rich locations can also contain "fix-it hints", giving suggestions 1516 for the user on how to edit their code to fix a problem. These 1517 can be expressed as insertions, replacements, and removals of text. 1518 The edits by default are relative to the zeroth range within the 1519 rich_location, but optionally they can be expressed relative to 1520 other locations (using various overloaded methods of the form 1521 rich_location::add_fixit_*). 1522 1523 For example: 1524 1525 Example F: fix-it hint: insert_before 1526 ************************************* 1527 ptr = arr[0]; 1528 ^~~~~~ 1529 & 1530 This rich location has a single range (range 0) covering "arr[0]", 1531 with the caret at the start. The rich location has a single 1532 insertion fix-it hint, inserted before range 0, added via 1533 richloc.add_fixit_insert_before ("&"); 1534 1535 Example G: multiple fix-it hints: insert_before and insert_after 1536 **************************************************************** 1537 #define FN(ARG0, ARG1, ARG2) fn(ARG0, ARG1, ARG2) 1538 ^~~~ ^~~~ ^~~~ 1539 ( ) ( ) ( ) 1540 This rich location has three ranges, covering "arg0", "arg1", 1541 and "arg2", all with caret-printing enabled. 1542 The rich location has 6 insertion fix-it hints: each arg 1543 has a pair of insertion fix-it hints, suggesting wrapping 1544 them with parentheses: one a '(' inserted before, 1545 the other a ')' inserted after, added via 1546 richloc.add_fixit_insert_before (LOC, "("); 1547 and 1548 richloc.add_fixit_insert_after (LOC, ")"); 1549 1550 Example H: fix-it hint: removal 1551 ******************************* 1552 struct s {int i};; 1553 ^ 1554 - 1555 This rich location has a single range at the stray trailing 1556 semicolon, along with a single removal fix-it hint, covering 1557 the same range, added via: 1558 richloc.add_fixit_remove (); 1559 1560 Example I: fix-it hint: replace 1561 ******************************* 1562 c = s.colour; 1563 ^~~~~~ 1564 color 1565 This rich location has a single range (range 0) covering "colour", 1566 and a single "replace" fix-it hint, covering the same range, 1567 added via 1568 richloc.add_fixit_replace ("color"); 1569 1570 Example J: fix-it hint: line insertion 1571 ************************************** 1572 1573 3 | #include <stddef.h> 1574 + |+#include <stdio.h> 1575 4 | int the_next_line; 1576 1577 This rich location has a single range at line 4 column 1, marked 1578 with SHOW_LINES_WITHOUT_RANGE (to avoid printing a meaningless caret 1579 on the "i" of int). It has a insertion fix-it hint of the string 1580 "#include <stdio.h>\n". 1581 1582 Adding a fix-it hint can fail: for example, attempts to insert content 1583 at the transition between two line maps may fail due to there being no 1584 location_t value to express the new location. 1585 1586 Attempts to add a fix-it hint within a macro expansion will fail. 1587 1588 There is only limited support for newline characters in fix-it hints: 1589 only hints with newlines which insert an entire new line are permitted, 1590 inserting at the start of a line, and finishing with a newline 1591 (with no interior newline characters). Other attempts to add 1592 fix-it hints containing newline characters will fail. 1593 Similarly, attempts to delete or replace a range *affecting* multiple 1594 lines will fail. 1595 1596 The rich_location API handles these failures gracefully, so that 1597 diagnostics can attempt to add fix-it hints without each needing 1598 extensive checking. 1599 1600 Fix-it hints within a rich_location are "atomic": if any hints can't 1601 be applied, none of them will be (tracked by the m_seen_impossible_fixit 1602 flag), and no fix-its hints will be displayed for that rich_location. 1603 This implies that diagnostic messages need to be worded in such a way 1604 that they make sense whether or not the fix-it hints are displayed, 1605 or that richloc.seen_impossible_fixit_p () should be checked before 1606 issuing the diagnostics. */ 1607 1608class rich_location 1609{ 1610 public: 1611 /* Constructors. */ 1612 1613 /* Constructing from a location. */ 1614 rich_location (line_maps *set, location_t loc, 1615 const range_label *label = NULL); 1616 1617 /* Destructor. */ 1618 ~rich_location (); 1619 1620 /* Accessors. */ 1621 location_t get_loc () const { return get_loc (0); } 1622 location_t get_loc (unsigned int idx) const; 1623 1624 void 1625 add_range (location_t loc, 1626 enum range_display_kind range_display_kind 1627 = SHOW_RANGE_WITHOUT_CARET, 1628 const range_label *label = NULL); 1629 1630 void 1631 set_range (unsigned int idx, location_t loc, 1632 enum range_display_kind range_display_kind); 1633 1634 unsigned int get_num_locations () const { return m_ranges.count (); } 1635 1636 const location_range *get_range (unsigned int idx) const; 1637 location_range *get_range (unsigned int idx); 1638 1639 expanded_location get_expanded_location (unsigned int idx); 1640 1641 void 1642 override_column (int column); 1643 1644 /* Fix-it hints. */ 1645 1646 /* Methods for adding insertion fix-it hints. */ 1647 1648 /* Suggest inserting NEW_CONTENT immediately before the primary 1649 range's start. */ 1650 void 1651 add_fixit_insert_before (const char *new_content); 1652 1653 /* Suggest inserting NEW_CONTENT immediately before the start of WHERE. */ 1654 void 1655 add_fixit_insert_before (location_t where, 1656 const char *new_content); 1657 1658 /* Suggest inserting NEW_CONTENT immediately after the end of the primary 1659 range. */ 1660 void 1661 add_fixit_insert_after (const char *new_content); 1662 1663 /* Suggest inserting NEW_CONTENT immediately after the end of WHERE. */ 1664 void 1665 add_fixit_insert_after (location_t where, 1666 const char *new_content); 1667 1668 /* Methods for adding removal fix-it hints. */ 1669 1670 /* Suggest removing the content covered by range 0. */ 1671 void 1672 add_fixit_remove (); 1673 1674 /* Suggest removing the content covered between the start and finish 1675 of WHERE. */ 1676 void 1677 add_fixit_remove (location_t where); 1678 1679 /* Suggest removing the content covered by SRC_RANGE. */ 1680 void 1681 add_fixit_remove (source_range src_range); 1682 1683 /* Methods for adding "replace" fix-it hints. */ 1684 1685 /* Suggest replacing the content covered by range 0 with NEW_CONTENT. */ 1686 void 1687 add_fixit_replace (const char *new_content); 1688 1689 /* Suggest replacing the content between the start and finish of 1690 WHERE with NEW_CONTENT. */ 1691 void 1692 add_fixit_replace (location_t where, 1693 const char *new_content); 1694 1695 /* Suggest replacing the content covered by SRC_RANGE with 1696 NEW_CONTENT. */ 1697 void 1698 add_fixit_replace (source_range src_range, 1699 const char *new_content); 1700 1701 unsigned int get_num_fixit_hints () const { return m_fixit_hints.count (); } 1702 fixit_hint *get_fixit_hint (int idx) const { return m_fixit_hints[idx]; } 1703 fixit_hint *get_last_fixit_hint () const; 1704 bool seen_impossible_fixit_p () const { return m_seen_impossible_fixit; } 1705 1706 /* Set this if the fix-it hints are not suitable to be 1707 automatically applied. 1708 1709 For example, if you are suggesting more than one 1710 mutually exclusive solution to a problem, then 1711 it doesn't make sense to apply all of the solutions; 1712 manual intervention is required. 1713 1714 If set, then the fix-it hints in the rich_location will 1715 be printed, but will not be added to generated patches, 1716 or affect the modified version of the file. */ 1717 void fixits_cannot_be_auto_applied () 1718 { 1719 m_fixits_cannot_be_auto_applied = true; 1720 } 1721 1722 bool fixits_can_be_auto_applied_p () const 1723 { 1724 return !m_fixits_cannot_be_auto_applied; 1725 } 1726 1727 /* An optional path through the code. */ 1728 const diagnostic_path *get_path () const { return m_path; } 1729 void set_path (const diagnostic_path *path) { m_path = path; } 1730 1731private: 1732 bool reject_impossible_fixit (location_t where); 1733 void stop_supporting_fixits (); 1734 void maybe_add_fixit (location_t start, 1735 location_t next_loc, 1736 const char *new_content); 1737 1738public: 1739 static const int STATICALLY_ALLOCATED_RANGES = 3; 1740 1741protected: 1742 line_maps *m_line_table; 1743 semi_embedded_vec <location_range, STATICALLY_ALLOCATED_RANGES> m_ranges; 1744 1745 int m_column_override; 1746 1747 bool m_have_expanded_location; 1748 expanded_location m_expanded_location; 1749 1750 static const int MAX_STATIC_FIXIT_HINTS = 2; 1751 semi_embedded_vec <fixit_hint *, MAX_STATIC_FIXIT_HINTS> m_fixit_hints; 1752 1753 bool m_seen_impossible_fixit; 1754 bool m_fixits_cannot_be_auto_applied; 1755 1756 const diagnostic_path *m_path; 1757}; 1758 1759/* A struct for the result of range_label::get_text: a NUL-terminated buffer 1760 of localized text, and a flag to determine if the caller should "free" the 1761 buffer. */ 1762 1763class label_text 1764{ 1765public: 1766 label_text () 1767 : m_buffer (NULL), m_caller_owned (false) 1768 {} 1769 1770 void maybe_free () 1771 { 1772 if (m_caller_owned) 1773 free (m_buffer); 1774 } 1775 1776 /* Create a label_text instance that borrows BUFFER from a 1777 longer-lived owner. */ 1778 static label_text borrow (const char *buffer) 1779 { 1780 return label_text (const_cast <char *> (buffer), false); 1781 } 1782 1783 /* Create a label_text instance that takes ownership of BUFFER. */ 1784 static label_text take (char *buffer) 1785 { 1786 return label_text (buffer, true); 1787 } 1788 1789 /* Take ownership of the buffer, copying if necessary. */ 1790 char *take_or_copy () 1791 { 1792 if (m_caller_owned) 1793 return m_buffer; 1794 else 1795 return xstrdup (m_buffer); 1796 } 1797 1798 char *m_buffer; 1799 bool m_caller_owned; 1800 1801private: 1802 label_text (char *buffer, bool owned) 1803 : m_buffer (buffer), m_caller_owned (owned) 1804 {} 1805}; 1806 1807/* Abstract base class for labelling a range within a rich_location 1808 (e.g. for labelling expressions with their type). 1809 1810 Generating the text could require non-trivial work, so this work 1811 is delayed (via the "get_text" virtual function) until the diagnostic 1812 printing code "knows" it needs it, thus avoiding doing it e.g. for 1813 warnings that are filtered by command-line flags. This virtual 1814 function also isolates libcpp and the diagnostics subsystem from 1815 the front-end and middle-end-specific code for generating the text 1816 for the labels. 1817 1818 Like the rich_location instances they annotate, range_label instances 1819 are intended to be allocated on the stack when generating diagnostics, 1820 and to be short-lived. */ 1821 1822class range_label 1823{ 1824 public: 1825 virtual ~range_label () {} 1826 1827 /* Get localized text for the label. 1828 The RANGE_IDX is provided, allowing for range_label instances to be 1829 shared by multiple ranges if need be (the "flyweight" design pattern). */ 1830 virtual label_text get_text (unsigned range_idx) const = 0; 1831}; 1832 1833/* A fix-it hint: a suggested insertion, replacement, or deletion of text. 1834 We handle these three types of edit with one class, by representing 1835 them as replacement of a half-open range: 1836 [start, next_loc) 1837 Insertions have start == next_loc: "replace" the empty string at the 1838 start location with the new string. 1839 Deletions are replacement with the empty string. 1840 1841 There is only limited support for newline characters in fix-it hints 1842 as noted above in the comment for class rich_location. 1843 A fixit_hint instance can have at most one newline character; if 1844 present, the newline character must be the final character of 1845 the content (preventing e.g. fix-its that split a pre-existing line). */ 1846 1847class fixit_hint 1848{ 1849 public: 1850 fixit_hint (location_t start, 1851 location_t next_loc, 1852 const char *new_content); 1853 ~fixit_hint () { free (m_bytes); } 1854 1855 bool affects_line_p (const char *file, int line) const; 1856 location_t get_start_loc () const { return m_start; } 1857 location_t get_next_loc () const { return m_next_loc; } 1858 bool maybe_append (location_t start, 1859 location_t next_loc, 1860 const char *new_content); 1861 1862 const char *get_string () const { return m_bytes; } 1863 size_t get_length () const { return m_len; } 1864 1865 bool insertion_p () const { return m_start == m_next_loc; } 1866 1867 bool ends_with_newline_p () const; 1868 1869 private: 1870 /* We don't use source_range here since, unlike most places, 1871 this is a half-open/half-closed range: 1872 [start, next_loc) 1873 so that we can support insertion via start == next_loc. */ 1874 location_t m_start; 1875 location_t m_next_loc; 1876 char *m_bytes; 1877 size_t m_len; 1878}; 1879 1880 1881/* This is enum is used by the function linemap_resolve_location 1882 below. The meaning of the values is explained in the comment of 1883 that function. */ 1884enum location_resolution_kind 1885{ 1886 LRK_MACRO_EXPANSION_POINT, 1887 LRK_SPELLING_LOCATION, 1888 LRK_MACRO_DEFINITION_LOCATION 1889}; 1890 1891/* Resolve a virtual location into either a spelling location, an 1892 expansion point location or a token argument replacement point 1893 location. Return the map that encodes the virtual location as well 1894 as the resolved location. 1895 1896 If LOC is *NOT* the location of a token resulting from the 1897 expansion of a macro, then the parameter LRK (which stands for 1898 Location Resolution Kind) is ignored and the resulting location 1899 just equals the one given in argument. 1900 1901 Now if LOC *IS* the location of a token resulting from the 1902 expansion of a macro, this is what happens. 1903 1904 * If LRK is set to LRK_MACRO_EXPANSION_POINT 1905 ------------------------------- 1906 1907 The virtual location is resolved to the first macro expansion point 1908 that led to this macro expansion. 1909 1910 * If LRK is set to LRK_SPELLING_LOCATION 1911 ------------------------------------- 1912 1913 The virtual location is resolved to the locus where the token has 1914 been spelled in the source. This can follow through all the macro 1915 expansions that led to the token. 1916 1917 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION 1918 -------------------------------------- 1919 1920 The virtual location is resolved to the locus of the token in the 1921 context of the macro definition. 1922 1923 If LOC is the locus of a token that is an argument of a 1924 function-like macro [replacing a parameter in the replacement list 1925 of the macro] the virtual location is resolved to the locus of the 1926 parameter that is replaced, in the context of the definition of the 1927 macro. 1928 1929 If LOC is the locus of a token that is not an argument of a 1930 function-like macro, then the function behaves as if LRK was set to 1931 LRK_SPELLING_LOCATION. 1932 1933 If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the 1934 returned location. Note that if the returned location wasn't originally 1935 encoded by a map, the *MAP is set to NULL. This can happen if LOC 1936 resolves to a location reserved for the client code, like 1937 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */ 1938 1939location_t linemap_resolve_location (class line_maps *, 1940 location_t loc, 1941 enum location_resolution_kind lrk, 1942 const line_map_ordinary **loc_map); 1943 1944/* Suppose that LOC is the virtual location of a token coming from the 1945 expansion of a macro M. This function then steps up to get the 1946 location L of the point where M got expanded. If L is a spelling 1947 location inside a macro expansion M', then this function returns 1948 the point where M' was expanded. LOC_MAP is an output parameter. 1949 When non-NULL, *LOC_MAP is set to the map of the returned 1950 location. */ 1951location_t linemap_unwind_toward_expansion (class line_maps *, 1952 location_t loc, 1953 const line_map **loc_map); 1954 1955/* If LOC is the virtual location of a token coming from the expansion 1956 of a macro M and if its spelling location is reserved (e.g, a 1957 location for a built-in token), then this function unwinds (using 1958 linemap_unwind_toward_expansion) the location until a location that 1959 is not reserved and is not in a system header is reached. In other 1960 words, this unwinds the reserved location until a location that is 1961 in real source code is reached. 1962 1963 Otherwise, if the spelling location for LOC is not reserved or if 1964 LOC doesn't come from the expansion of a macro, the function 1965 returns LOC as is and *MAP is not touched. 1966 1967 *MAP is set to the map of the returned location if the later is 1968 different from LOC. */ 1969location_t linemap_unwind_to_first_non_reserved_loc (class line_maps *, 1970 location_t loc, 1971 const line_map **map); 1972 1973/* Expand source code location LOC and return a user readable source 1974 code location. LOC must be a spelling (non-virtual) location. If 1975 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source 1976 location is returned. */ 1977expanded_location linemap_expand_location (class line_maps *, 1978 const line_map *, 1979 location_t loc); 1980 1981/* Statistics about maps allocation and usage as returned by 1982 linemap_get_statistics. */ 1983struct linemap_stats 1984{ 1985 long num_ordinary_maps_allocated; 1986 long num_ordinary_maps_used; 1987 long ordinary_maps_allocated_size; 1988 long ordinary_maps_used_size; 1989 long num_expanded_macros; 1990 long num_macro_tokens; 1991 long num_macro_maps_used; 1992 long macro_maps_allocated_size; 1993 long macro_maps_used_size; 1994 long macro_maps_locations_size; 1995 long duplicated_macro_maps_locations_size; 1996 long adhoc_table_size; 1997 long adhoc_table_entries_used; 1998}; 1999 2000/* Return the highest location emitted for a given file for which 2001 there is a line map in SET. FILE_NAME is the file name to 2002 consider. If the function returns TRUE, *LOC is set to the highest 2003 location emitted for that file. */ 2004bool linemap_get_file_highest_location (class line_maps * set, 2005 const char *file_name, 2006 location_t *loc); 2007 2008/* Compute and return statistics about the memory consumption of some 2009 parts of the line table SET. */ 2010void linemap_get_statistics (line_maps *, struct linemap_stats *); 2011 2012/* Dump debugging information about source location LOC into the file 2013 stream STREAM. SET is the line map set LOC comes from. */ 2014void linemap_dump_location (line_maps *, location_t, FILE *); 2015 2016/* Dump line map at index IX in line table SET to STREAM. If STREAM 2017 is NULL, use stderr. IS_MACRO is true if the caller wants to 2018 dump a macro map, false otherwise. */ 2019void linemap_dump (FILE *, line_maps *, unsigned, bool); 2020 2021/* Dump line table SET to STREAM. If STREAM is NULL, stderr is used. 2022 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO 2023 specifies how many macro maps to dump. */ 2024void line_table_dump (FILE *, line_maps *, unsigned int, unsigned int); 2025 2026/* An enum for distinguishing the various parts within a location_t. */ 2027 2028enum location_aspect 2029{ 2030 LOCATION_ASPECT_CARET, 2031 LOCATION_ASPECT_START, 2032 LOCATION_ASPECT_FINISH 2033}; 2034 2035/* The rich_location class requires a way to expand location_t instances. 2036 We would directly use expand_location_to_spelling_point, which is 2037 implemented in gcc/input.c, but we also need to use it for rich_location 2038 within genmatch.c. 2039 Hence we require client code of libcpp to implement the following 2040 symbol. */ 2041extern expanded_location 2042linemap_client_expand_location_to_spelling_point (location_t, 2043 enum location_aspect); 2044 2045#endif /* !LIBCPP_LINE_MAP_H */ 2046