contrib/gcc-5.0/libcpp/line-map.c

   1 /* Map logical line numbers to (source file, line number) pairs.
   2    Copyright (C) 2001-2015 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation; either version 3, or (at your option) any
   7 later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along 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 #include "config.h"
  23 #include "system.h"
  24 #include "line-map.h"
  25 #include "cpplib.h"
  26 #include "internal.h"
  27 #include "hashtab.h"
  28
  29 static void trace_include (const struct line_maps *, const struct line_map *);
  30 static const struct line_map * linemap_ordinary_map_lookup (struct line_maps *,
  31                                                             source_location);
  32 static const struct line_map* linemap_macro_map_lookup (struct line_maps *,
  33                                                         source_location);
  34 static source_location linemap_macro_map_loc_to_def_point
  35 (const struct line_map*, source_location);
  36 static source_location linemap_macro_map_loc_unwind_toward_spelling
  37 (const struct line_map*, source_location);
  38 static source_location linemap_macro_map_loc_to_exp_point
  39 (const struct line_map*, source_location);
  40 static source_location linemap_macro_loc_to_spelling_point
  41 (struct line_maps *, source_location, const struct line_map **);
  42 static source_location linemap_macro_loc_to_def_point (struct line_maps *,
  43                                                        source_location,
  44                                                        const struct line_map **);
  45 static source_location linemap_macro_loc_to_exp_point (struct line_maps *,
  46                                                        source_location,
  47                                                        const struct line_map **);
  48
  49 /* Counters defined in macro.c.  */
  50 extern unsigned num_expanded_macros_counter;
  51 extern unsigned num_macro_tokens_counter;
  52
  53 /* Hash function for location_adhoc_data hashtable.  */
  54
  55 static hashval_t
  56 location_adhoc_data_hash (const void *l)
  57 {
  58   const struct location_adhoc_data *lb =
  59       (const struct location_adhoc_data *) l;
  60   return (hashval_t) lb->locus + (size_t) lb->data;
  61 }
  62
  63 /* Compare function for location_adhoc_data hashtable.  */
  64
  65 static int
  66 location_adhoc_data_eq (const void *l1, const void *l2)
  67 {
  68   const struct location_adhoc_data *lb1 =
  69       (const struct location_adhoc_data *) l1;
  70   const struct location_adhoc_data *lb2 =
  71       (const struct location_adhoc_data *) l2;
  72   return lb1->locus == lb2->locus && lb1->data == lb2->data;
  73 }
  74
  75 /* Update the hashtable when location_adhoc_data is reallocated.  */
  76
  77 static int
  78 location_adhoc_data_update (void **slot, void *data)
  79 {
  80   *((char **) slot) += *((long long *) data);
  81   return 1;
  82 }
  83
  84 /* Rebuild the hash table from the location adhoc data.  */
  85
  86 void
  87 rebuild_location_adhoc_htab (struct line_maps *set)
  88 {
  89   unsigned i;
  90   set->location_adhoc_data_map.htab =
  91       htab_create (100, location_adhoc_data_hash, location_adhoc_data_eq, NULL);
  92   for (i = 0; i < set->location_adhoc_data_map.curr_loc; i++)
  93     htab_find_slot (set->location_adhoc_data_map.htab,
  94                     set->location_adhoc_data_map.data + i, INSERT);
  95 }
  96
  97 /* Combine LOCUS and DATA to a combined adhoc loc.  */
  98
  99 source_location
 100 get_combined_adhoc_loc (struct line_maps *set,
 101                         source_location locus, void *data)
 102 {
 103   struct location_adhoc_data lb;
 104   struct location_adhoc_data **slot;
 105
 106   linemap_assert (data);
 107
 108   if (IS_ADHOC_LOC (locus))
 109     locus
 110       = set->location_adhoc_data_map.data[locus & MAX_SOURCE_LOCATION].locus;
 111   if (locus == 0 && data == NULL)
 112     return 0;
 113   lb.locus = locus;
 114   lb.data = data;
 115   slot = (struct location_adhoc_data **)
 116       htab_find_slot (set->location_adhoc_data_map.htab, &lb, INSERT);
 117   if (*slot == NULL)
 118     {
 119       if (set->location_adhoc_data_map.curr_loc >=
 120           set->location_adhoc_data_map.allocated)
 121         {
 122           char *orig_data = (char *) set->location_adhoc_data_map.data;
 123           long long offset;
 124           /* Cast away extern "C" from the type of xrealloc.  */
 125           line_map_realloc reallocator = (set->reallocator
 126                                           ? set->reallocator
 127                                           : (line_map_realloc) xrealloc);
 128
 129           if (set->location_adhoc_data_map.allocated == 0)
 130             set->location_adhoc_data_map.allocated = 128;
 131           else
 132             set->location_adhoc_data_map.allocated *= 2;
 133           set->location_adhoc_data_map.data = (struct location_adhoc_data *)
 134               reallocator (set->location_adhoc_data_map.data,
 135                            set->location_adhoc_data_map.allocated
 136                            * sizeof (struct location_adhoc_data));
 137           offset = (char *) (set->location_adhoc_data_map.data) - orig_data;
 138           if (set->location_adhoc_data_map.allocated > 128)
 139             htab_traverse (set->location_adhoc_data_map.htab,
 140                            location_adhoc_data_update, &offset);
 141         }
 142       *slot = set->location_adhoc_data_map.data
 143               + set->location_adhoc_data_map.curr_loc;
 144       set->location_adhoc_data_map.data[set->location_adhoc_data_map.curr_loc++]
 145         = lb;
 146     }
 147   return ((*slot) - set->location_adhoc_data_map.data) | 0x80000000;
 148 }
 149
 150 /* Return the data for the adhoc loc.  */
 151
 152 void *
 153 get_data_from_adhoc_loc (struct line_maps *set, source_location loc)
 154 {
 155   linemap_assert (IS_ADHOC_LOC (loc));
 156   return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
 157 }
 158
 159 /* Return the location for the adhoc loc.  */
 160
 161 source_location
 162 get_location_from_adhoc_loc (struct line_maps *set, source_location loc)
 163 {
 164   linemap_assert (IS_ADHOC_LOC (loc));
 165   return set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
 166 }
 167
 168 /* Finalize the location_adhoc_data structure.  */
 169 void
 170 location_adhoc_data_fini (struct line_maps *set)
 171 {
 172   htab_delete (set->location_adhoc_data_map.htab);
 173 }
 174
 175 /* Initialize a line map set.  */
 176
 177 void
 178 linemap_init (struct line_maps *set,
 179               source_location builtin_location)
 180 {
 181   memset (set, 0, sizeof (struct line_maps));
 182   set->highest_location = RESERVED_LOCATION_COUNT - 1;
 183   set->highest_line = RESERVED_LOCATION_COUNT - 1;
 184   set->location_adhoc_data_map.htab =
 185       htab_create (100, location_adhoc_data_hash, location_adhoc_data_eq, NULL);
 186   set->builtin_location = builtin_location;
 187 }
 188
 189 /* Check for and warn about line_maps entered but not exited.  */
 190
 191 void
 192 linemap_check_files_exited (struct line_maps *set)
 193 {
 194   struct line_map *map;
 195   /* Depending upon whether we are handling preprocessed input or
 196      not, this can be a user error or an ICE.  */
 197   for (map = LINEMAPS_LAST_ORDINARY_MAP (set);
 198        ! MAIN_FILE_P (map);
 199        map = INCLUDED_FROM (set, map))
 200     fprintf (stderr, "line-map.c: file \"%s\" entered but not left\n",
 201              ORDINARY_MAP_FILE_NAME (map));
 202 }
 203
 204 /* Create a new line map in the line map set SET, and return it.
 205    REASON is the reason of creating the map. It determines the type
 206    of map created (ordinary or macro map). Note that ordinary maps and
 207    macro maps are allocated in different memory location.  */
 208
 209 static struct line_map *
 210 new_linemap (struct line_maps *set,
 211              enum lc_reason reason)
 212 {
 213   /* Depending on this variable, a macro map would be allocated in a
 214      different memory location than an ordinary map.  */
 215   bool macro_map_p = (reason == LC_ENTER_MACRO);
 216   struct line_map *result;
 217
 218   if (LINEMAPS_USED (set, macro_map_p) == LINEMAPS_ALLOCATED (set, macro_map_p))
 219     {
 220       /* We ran out of allocated line maps. Let's allocate more.  */
 221       unsigned alloc_size;
 222
 223       /* Cast away extern "C" from the type of xrealloc.  */
 224       line_map_realloc reallocator = (set->reallocator
 225                                       ? set->reallocator
 226                                       : (line_map_realloc) xrealloc);
 227       line_map_round_alloc_size_func round_alloc_size =
 228         set->round_alloc_size;
 229
 230       /* We are going to execute some dance to try to reduce the
 231          overhead of the memory allocator, in case we are using the
 232          ggc-page.c one.
 233
 234          The actual size of memory we are going to get back from the
 235          allocator is the smallest power of 2 that is greater than the
 236          size we requested.  So let's consider that size then.  */
 237
 238       alloc_size =
 239         (2 * LINEMAPS_ALLOCATED (set, macro_map_p) +  256)
 240         * sizeof (struct line_map);
 241
 242       /* Get the actual size of memory that is going to be allocated
 243          by the allocator.  */
 244       alloc_size = round_alloc_size (alloc_size);
 245
 246       /* Now alloc_size contains the exact memory size we would get if
 247          we have asked for the initial alloc_size amount of memory.
 248          Let's get back to the number of macro map that amounts
 249          to.  */
 250       LINEMAPS_ALLOCATED (set, macro_map_p) =
 251         alloc_size / (sizeof (struct line_map));
 252
 253       /* And now let's really do the re-allocation.  */
 254       LINEMAPS_MAPS (set, macro_map_p) =
 255         (struct line_map *) (*reallocator)
 256         (LINEMAPS_MAPS (set, macro_map_p),
 257          (LINEMAPS_ALLOCATED (set, macro_map_p)
 258           * sizeof (struct line_map)));
 259
 260       result =
 261         &LINEMAPS_MAPS (set, macro_map_p)[LINEMAPS_USED (set, macro_map_p)];
 262       memset (result, 0,
 263               ((LINEMAPS_ALLOCATED (set, macro_map_p)
 264                 - LINEMAPS_USED (set, macro_map_p))
 265                * sizeof (struct line_map)));
 266     }
 267   else
 268     result =
 269       &LINEMAPS_MAPS (set, macro_map_p)[LINEMAPS_USED (set, macro_map_p)];
 270
 271   LINEMAPS_USED (set, macro_map_p)++;
 272
 273   result->reason = reason;
 274   return result;
 275 }
 276
 277 /* Add a mapping of logical source line to physical source file and
 278    line number.
 279
 280    The text pointed to by TO_FILE must have a lifetime
 281    at least as long as the final call to lookup_line ().  An empty
 282    TO_FILE means standard input.  If reason is LC_LEAVE, and
 283    TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
 284    natural values considering the file we are returning to.
 285
 286    FROM_LINE should be monotonic increasing across calls to this
 287    function.  A call to this function can relocate the previous set of
 288    maps, so any stored line_map pointers should not be used.  */
 289
 290 const struct line_map *
 291 linemap_add (struct line_maps *set, enum lc_reason reason,
 292              unsigned int sysp, const char *to_file, linenum_type to_line)
 293 {
 294   struct line_map *map;
 295   source_location start_location = set->highest_location + 1;
 296
 297   linemap_assert (!(LINEMAPS_ORDINARY_USED (set)
 298                     && (start_location
 299                         < MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set)))));
 300
 301   /* When we enter the file for the first time reason cannot be
 302      LC_RENAME.  */
 303   linemap_assert (!(set->depth == 0 && reason == LC_RENAME));
 304
 305   /* If we are leaving the main file, return a NULL map.  */
 306   if (reason == LC_LEAVE
 307       && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set))
 308       && to_file == NULL)
 309     {
 310       set->depth--;
 311       return NULL;
 312     }
 313
 314   map = new_linemap (set, reason);
 315
 316   if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM)
 317     to_file = "<stdin>";
 318
 319   if (reason == LC_RENAME_VERBATIM)
 320     reason = LC_RENAME;
 321
 322   if (reason == LC_LEAVE)
 323     {
 324       /* When we are just leaving an "included" file, and jump to the next
 325          location inside the "includer" right after the #include
 326          "included", this variable points the map in use right before the
 327          #include "included", inside the same "includer" file.  */
 328       struct line_map *from;
 329       bool error;
 330
 331       if (MAIN_FILE_P (map - 1))
 332         {
 333           /* So this _should_ mean we are leaving the main file --
 334              effectively ending the compilation unit. But to_file not
 335              being NULL means the caller thinks we are leaving to
 336              another file. This is an erroneous behaviour but we'll
 337              try to recover from it. Let's pretend we are not leaving
 338              the main file.  */
 339           error = true;
 340           reason = LC_RENAME;
 341           from = map - 1;
 342         }
 343       else
 344         {
 345           /* (MAP - 1) points to the map we are leaving. The
 346              map from which (MAP - 1) got included should be the map
 347              that comes right before MAP in the same file.  */
 348           from = INCLUDED_FROM (set, map - 1);
 349           error = to_file && filename_cmp (ORDINARY_MAP_FILE_NAME (from),
 350                                            to_file);
 351         }
 352
 353       /* Depending upon whether we are handling preprocessed input or
 354          not, this can be a user error or an ICE.  */
 355       if (error)
 356         fprintf (stderr, "line-map.c: file \"%s\" left but not entered\n",
 357                  to_file);
 358
 359       /* A TO_FILE of NULL is special - we use the natural values.  */
 360       if (error || to_file == NULL)
 361         {
 362           to_file = ORDINARY_MAP_FILE_NAME (from);
 363           to_line = SOURCE_LINE (from, from[1].start_location);
 364           sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (from);
 365         }
 366     }
 367
 368   linemap_assert (reason != LC_ENTER_MACRO);
 369   ORDINARY_MAP_IN_SYSTEM_HEADER_P (map) = sysp;
 370   MAP_START_LOCATION (map) = start_location;
 371   ORDINARY_MAP_FILE_NAME (map) = to_file;
 372   ORDINARY_MAP_STARTING_LINE_NUMBER (map) = to_line;
 373   LINEMAPS_ORDINARY_CACHE (set) = LINEMAPS_ORDINARY_USED (set) - 1;
 374   ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) = 0;
 375   set->highest_location = start_location;
 376   set->highest_line = start_location;
 377   set->max_column_hint = 0;
 378
 379   if (reason == LC_ENTER)
 380     {
 381       ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
 382         set->depth == 0 ? -1 : (int) (LINEMAPS_ORDINARY_USED (set) - 2);
 383       set->depth++;
 384       if (set->trace_includes)
 385         trace_include (set, map);
 386     }
 387   else if (reason == LC_RENAME)
 388     ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
 389       ORDINARY_MAP_INCLUDER_FILE_INDEX (&map[-1]);
 390   else if (reason == LC_LEAVE)
 391     {
 392       set->depth--;
 393       ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
 394         ORDINARY_MAP_INCLUDER_FILE_INDEX (INCLUDED_FROM (set, map - 1));
 395     }
 396
 397   return map;
 398 }
 399
 400 /* Returns TRUE if the line table set tracks token locations across
 401    macro expansion, FALSE otherwise.  */
 402
 403 bool
 404 linemap_tracks_macro_expansion_locs_p (struct line_maps *set)
 405 {
 406   return LINEMAPS_MACRO_MAPS (set) != NULL;
 407 }
 408
 409 /* Create a macro map.  A macro map encodes source locations of tokens
 410    that are part of a macro replacement-list, at a macro expansion
 411    point.  See the extensive comments of struct line_map and struct
 412    line_map_macro, in line-map.h.
 413
 414    This map shall be created when the macro is expanded.  The map
 415    encodes the source location of the expansion point of the macro as
 416    well as the "original" source location of each token that is part
 417    of the macro replacement-list.  If a macro is defined but never
 418    expanded, it has no macro map.  SET is the set of maps the macro
 419    map should be part of.  MACRO_NODE is the macro which the new macro
 420    map should encode source locations for.  EXPANSION is the location
 421    of the expansion point of MACRO. For function-like macros
 422    invocations, it's best to make it point to the closing parenthesis
 423    of the macro, rather than the the location of the first character
 424    of the macro.  NUM_TOKENS is the number of tokens that are part of
 425    the replacement-list of MACRO.
 426
 427    Note that when we run out of the integer space available for source
 428    locations, this function returns NULL.  In that case, callers of
 429    this function cannot encode {line,column} pairs into locations of
 430    macro tokens anymore.  */
 431
 432 const struct line_map *
 433 linemap_enter_macro (struct line_maps *set, struct cpp_hashnode *macro_node,
 434                      source_location expansion, unsigned int num_tokens)
 435 {
 436   struct line_map *map;
 437   source_location start_location;
 438   /* Cast away extern "C" from the type of xrealloc.  */
 439   line_map_realloc reallocator = (set->reallocator
 440                                   ? set->reallocator
 441                                   : (line_map_realloc) xrealloc);
 442
 443   start_location = LINEMAPS_MACRO_LOWEST_LOCATION (set) - num_tokens;
 444
 445   if (start_location <= set->highest_line
 446       || start_location > LINEMAPS_MACRO_LOWEST_LOCATION (set))
 447     /* We ran out of macro map space.   */
 448     return NULL;
 449
 450   map = new_linemap (set, LC_ENTER_MACRO);
 451
 452   MAP_START_LOCATION (map) = start_location;
 453   MACRO_MAP_MACRO (map) = macro_node;
 454   MACRO_MAP_NUM_MACRO_TOKENS (map) = num_tokens;
 455   MACRO_MAP_LOCATIONS (map)
 456     = (source_location*) reallocator (NULL,
 457                                       2 * num_tokens
 458                                       * sizeof (source_location));
 459   MACRO_MAP_EXPANSION_POINT_LOCATION (map) = expansion;
 460   memset (MACRO_MAP_LOCATIONS (map), 0,
 461           num_tokens * sizeof (source_location));
 462
 463   LINEMAPS_MACRO_CACHE (set) = LINEMAPS_MACRO_USED (set) - 1;
 464
 465   return map;
 466 }
 467
 468 /* Create and return a virtual location for a token that is part of a
 469    macro expansion-list at a macro expansion point.  See the comment
 470    inside struct line_map_macro to see what an expansion-list exactly
 471    is.
 472
 473    A call to this function must come after a call to
 474    linemap_enter_macro.
 475
 476    MAP is the map into which the source location is created.  TOKEN_NO
 477    is the index of the token in the macro replacement-list, starting
 478    at number 0.
 479
 480    ORIG_LOC is the location of the token outside of this macro
 481    expansion.  If the token comes originally from the macro
 482    definition, it is the locus in the macro definition; otherwise it
 483    is a location in the context of the caller of this macro expansion
 484    (which is a virtual location or a source location if the caller is
 485    itself a macro expansion or not).
 486
 487    ORIG_PARM_REPLACEMENT_LOC is the location in the macro definition,
 488    either of the token itself or of a macro parameter that it
 489    replaces.  */
 490
 491 source_location
 492 linemap_add_macro_token (const struct line_map *map,
 493                          unsigned int token_no,
 494                          source_location orig_loc,
 495                          source_location orig_parm_replacement_loc)
 496 {
 497   source_location result;
 498
 499   linemap_assert (linemap_macro_expansion_map_p (map));
 500   linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
 501
 502   MACRO_MAP_LOCATIONS (map)[2 * token_no] = orig_loc;
 503   MACRO_MAP_LOCATIONS (map)[2 * token_no + 1] = orig_parm_replacement_loc;
 504
 505   result = MAP_START_LOCATION (map) + token_no;
 506   return result;
 507 }
 508
 509 /* Return a source_location for the start (i.e. column==0) of
 510    (physical) line TO_LINE in the current source file (as in the
 511    most recent linemap_add).   MAX_COLUMN_HINT is the highest column
 512    number we expect to use in this line (but it does not change
 513    the highest_location).  */
 514
 515 source_location
 516 linemap_line_start (struct line_maps *set, linenum_type to_line,
 517                     unsigned int max_column_hint)
 518 {
 519   struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
 520   source_location highest = set->highest_location;
 521   source_location r;
 522   linenum_type last_line =
 523     SOURCE_LINE (map, set->highest_line);
 524   int line_delta = to_line - last_line;
 525   bool add_map = false;
 526
 527   if (line_delta < 0
 528       || (line_delta > 10
 529           && line_delta * ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) > 1000)
 530       || (max_column_hint >= (1U << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map)))
 531       || (max_column_hint <= 80
 532           && ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) >= 10)
 533       || (highest > 0x60000000
 534           && (set->max_column_hint || highest > 0x70000000)))
 535     add_map = true;
 536   else
 537     max_column_hint = set->max_column_hint;
 538   if (add_map)
 539     {
 540       int column_bits;
 541       if (max_column_hint > 100000 || highest > 0x60000000)
 542         {
 543           /* If the column number is ridiculous or we've allocated a huge
 544              number of source_locations, give up on column numbers. */
 545           max_column_hint = 0;
 546           if (highest > 0x70000000)
 547             return 0;
 548           column_bits = 0;
 549         }
 550       else
 551         {
 552           column_bits = 7;
 553           while (max_column_hint >= (1U << column_bits))
 554             column_bits++;
 555           max_column_hint = 1U << column_bits;
 556         }
 557       /* Allocate the new line_map.  However, if the current map only has a
 558          single line we can sometimes just increase its column_bits instead. */
 559       if (line_delta < 0
 560           || last_line != ORDINARY_MAP_STARTING_LINE_NUMBER (map)
 561           || SOURCE_COLUMN (map, highest) >= (1U << column_bits))
 562         map = (struct line_map *) linemap_add (set, LC_RENAME,
 563                                                ORDINARY_MAP_IN_SYSTEM_HEADER_P
 564                                                (map),
 565                                                ORDINARY_MAP_FILE_NAME (map),
 566                                                to_line);
 567       ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) = column_bits;
 568       r = (MAP_START_LOCATION (map)
 569            + ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
 570               << column_bits));
 571     }
 572   else
 573     r = highest - SOURCE_COLUMN (map, highest)
 574       + (line_delta << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map));
 575
 576   /* Locations of ordinary tokens are always lower than locations of
 577      macro tokens.  */
 578   if (r >= LINEMAPS_MACRO_LOWEST_LOCATION (set))
 579     return 0;
 580
 581   set->highest_line = r;
 582   if (r > set->highest_location)
 583     set->highest_location = r;
 584   set->max_column_hint = max_column_hint;
 585   return r;
 586 }
 587
 588 /* Encode and return a source_location from a column number. The
 589    source line considered is the last source line used to call
 590    linemap_line_start, i.e, the last source line which a location was
 591    encoded from.  */
 592
 593 source_location
 594 linemap_position_for_column (struct line_maps *set, unsigned int to_column)
 595 {
 596   source_location r = set->highest_line;
 597
 598   linemap_assert
 599     (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
 600
 601   if (to_column >= set->max_column_hint)
 602     {
 603       if (r >= 0xC000000 || to_column > 100000)
 604         {
 605           /* Running low on source_locations - disable column numbers.  */
 606           return r;
 607         }
 608       else
 609         {
 610           struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
 611           r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
 612         }
 613     }
 614   r = r + to_column;
 615   if (r >= set->highest_location)
 616     set->highest_location = r;
 617   return r;
 618 }
 619
 620 /* Encode and return a source location from a given line and
 621    column.  */
 622
 623 source_location
 624 linemap_position_for_line_and_column (const struct line_map *map,
 625                                       linenum_type line,
 626                                       unsigned column)
 627 {
 628   linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (map) <= line);
 629
 630   return (MAP_START_LOCATION (map)
 631           + ((line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
 632              << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map))
 633           + (column & ((1 << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map)) - 1)));
 634 }
 635
 636 /* Encode and return a source_location starting from location LOC and
 637    shifting it by OFFSET columns.  This function does not support
 638    virtual locations.  */
 639
 640 source_location
 641 linemap_position_for_loc_and_offset (struct line_maps *set,
 642                                      source_location loc,
 643                                      unsigned int offset)
 644 {
 645   const struct line_map * map = NULL;
 646
 647   /* This function does not support virtual locations yet.  */
 648   if (linemap_assert_fails
 649       (!linemap_location_from_macro_expansion_p (set, loc)))
 650     return loc;
 651
 652   if (offset == 0
 653       /* Adding an offset to a reserved location (like
 654          UNKNOWN_LOCATION for the C/C++ FEs) does not really make
 655          sense.  So let's leave the location intact in that case.  */
 656       || loc < RESERVED_LOCATION_COUNT)
 657     return loc;
 658
 659   /* We find the real location and shift it.  */
 660   loc = linemap_resolve_location (set, loc, LRK_SPELLING_LOCATION, &map);
 661   /* The new location (loc + offset) should be higher than the first
 662      location encoded by MAP.  */
 663   if (linemap_assert_fails (MAP_START_LOCATION (map) < loc + offset))
 664     return loc;
 665
 666   /* If MAP is not the last line map of its set, then the new location
 667      (loc + offset) should be less than the first location encoded by
 668      the next line map of the set.  */
 669   if (map != LINEMAPS_LAST_ORDINARY_MAP (set))
 670     if (linemap_assert_fails (loc + offset < MAP_START_LOCATION (&map[1])))
 671       return loc;
 672
 673   offset += SOURCE_COLUMN (map, loc);
 674   if (linemap_assert_fails (offset < (1u << map->d.ordinary.column_bits)))
 675     return loc;
 676
 677   source_location r =
 678     linemap_position_for_line_and_column (map,
 679                                           SOURCE_LINE (map, loc),
 680                                           offset);
 681   if (linemap_assert_fails (r <= set->highest_location)
 682       || linemap_assert_fails (map == linemap_lookup (set, r)))
 683     return loc;
 684
 685   return r;
 686 }
 687
 688 /* Given a virtual source location yielded by a map (either an
 689    ordinary or a macro map), returns that map.  */
 690
 691 const struct line_map*
 692 linemap_lookup (struct line_maps *set, source_location line)
 693 {
 694   if (IS_ADHOC_LOC (line))
 695     line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
 696   if (linemap_location_from_macro_expansion_p (set, line))
 697     return linemap_macro_map_lookup (set, line);
 698   return linemap_ordinary_map_lookup (set, line);
 699 }
 700
 701 /* Given a source location yielded by an ordinary map, returns that
 702    map.  Since the set is built chronologically, the logical lines are
 703    monotonic increasing, and so the list is sorted and we can use a
 704    binary search.  */
 705
 706 static const struct line_map *
 707 linemap_ordinary_map_lookup (struct line_maps *set, source_location line)
 708 {
 709   unsigned int md, mn, mx;
 710   const struct line_map *cached, *result;
 711
 712   if (IS_ADHOC_LOC (line))
 713     line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
 714
 715   if (set ==  NULL || line < RESERVED_LOCATION_COUNT)
 716     return NULL;
 717
 718   mn = LINEMAPS_ORDINARY_CACHE (set);
 719   mx = LINEMAPS_ORDINARY_USED (set);
 720
 721   cached = LINEMAPS_ORDINARY_MAP_AT (set, mn);
 722   /* We should get a segfault if no line_maps have been added yet.  */
 723   if (line >= MAP_START_LOCATION (cached))
 724     {
 725       if (mn + 1 == mx || line < MAP_START_LOCATION (&cached[1]))
 726         return cached;
 727     }
 728   else
 729     {
 730       mx = mn;
 731       mn = 0;
 732     }
 733
 734   while (mx - mn > 1)
 735     {
 736       md = (mn + mx) / 2;
 737       if (MAP_START_LOCATION (LINEMAPS_ORDINARY_MAP_AT (set, md)) > line)
 738         mx = md;
 739       else
 740         mn = md;
 741     }
 742
 743   LINEMAPS_ORDINARY_CACHE (set) = mn;
 744   result = LINEMAPS_ORDINARY_MAP_AT (set, mn);
 745   linemap_assert (line >= MAP_START_LOCATION (result));
 746   return result;
 747 }
 748
 749 /* Given a source location yielded by a macro map, returns that map.
 750    Since the set is built chronologically, the logical lines are
 751    monotonic decreasing, and so the list is sorted and we can use a
 752    binary search.  */
 753
 754 static const struct line_map*
 755 linemap_macro_map_lookup (struct line_maps *set, source_location line)
 756 {
 757   unsigned int md, mn, mx;
 758   const struct line_map *cached, *result;
 759
 760   if (IS_ADHOC_LOC (line))
 761     line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
 762
 763   linemap_assert (line >= LINEMAPS_MACRO_LOWEST_LOCATION (set));
 764
 765   if (set ==  NULL)
 766     return NULL;
 767
 768   mn = LINEMAPS_MACRO_CACHE (set);
 769   mx = LINEMAPS_MACRO_USED (set);
 770   cached = LINEMAPS_MACRO_MAP_AT (set, mn);
 771
 772   if (line >= MAP_START_LOCATION (cached))
 773     {
 774       if (mn == 0 || line < MAP_START_LOCATION (&cached[-1]))
 775         return cached;
 776       mx = mn - 1;
 777       mn = 0;
 778     }
 779
 780   while (mn < mx)
 781     {
 782       md = (mx + mn) / 2;
 783       if (MAP_START_LOCATION (LINEMAPS_MACRO_MAP_AT (set, md)) > line)
 784         mn = md + 1;
 785       else
 786         mx = md;
 787     }
 788
 789   LINEMAPS_MACRO_CACHE (set) = mx;
 790   result = LINEMAPS_MACRO_MAP_AT (set, LINEMAPS_MACRO_CACHE (set));
 791   linemap_assert (MAP_START_LOCATION (result) <= line);
 792
 793   return result;
 794 }
 795
 796 /* Return TRUE if MAP encodes locations coming from a macro
 797    replacement-list at macro expansion point.  */
 798
 799 bool
 800 linemap_macro_expansion_map_p (const struct line_map *map)
 801 {
 802   if (!map)
 803     return false;
 804   return (map->reason == LC_ENTER_MACRO);
 805 }
 806
 807 /* If LOCATION is the locus of a token in a replacement-list of a
 808    macro expansion return the location of the macro expansion point.
 809
 810    Read the comments of struct line_map and struct line_map_macro in
 811    line-map.h to understand what a macro expansion point is.  */
 812
 813 static source_location
 814 linemap_macro_map_loc_to_exp_point (const struct line_map *map,
 815                                     source_location location ATTRIBUTE_UNUSED)
 816 {
 817   linemap_assert (linemap_macro_expansion_map_p (map)
 818                   && location >= MAP_START_LOCATION (map));
 819
 820   /* Make sure LOCATION is correct.  */
 821   linemap_assert ((location - MAP_START_LOCATION (map))
 822                   <  MACRO_MAP_NUM_MACRO_TOKENS (map));
 823
 824   return MACRO_MAP_EXPANSION_POINT_LOCATION (map);
 825 }
 826
 827 /* LOCATION is the source location of a token that belongs to a macro
 828    replacement-list as part of the macro expansion denoted by MAP.
 829
 830    Return the location of the token at the definition point of the
 831    macro.  */
 832
 833 static source_location
 834 linemap_macro_map_loc_to_def_point (const struct line_map *map,
 835                                     source_location location)
 836 {
 837   unsigned token_no;
 838
 839   linemap_assert (linemap_macro_expansion_map_p (map)
 840                   && location >= MAP_START_LOCATION (map));
 841   linemap_assert (location >= RESERVED_LOCATION_COUNT);
 842
 843   token_no = location - MAP_START_LOCATION (map);
 844   linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
 845
 846   location = MACRO_MAP_LOCATIONS (map)[2 * token_no + 1];
 847
 848   return location;
 849 }
 850
 851 /* If LOCATION is the locus of a token that is an argument of a
 852    function-like macro M and appears in the expansion of M, return the
 853    locus of that argument in the context of the caller of M.
 854
 855    In other words, this returns the xI location presented in the
 856    comments of line_map_macro above.  */
 857 source_location
 858 linemap_macro_map_loc_unwind_toward_spelling (const struct line_map* map,
 859                                               source_location location)
 860 {
 861   unsigned token_no;
 862
 863   linemap_assert (linemap_macro_expansion_map_p (map)
 864                   && location >= MAP_START_LOCATION (map));
 865   linemap_assert (location >= RESERVED_LOCATION_COUNT);
 866
 867   token_no = location - MAP_START_LOCATION (map);
 868   linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
 869
 870   location = MACRO_MAP_LOCATIONS (map)[2 * token_no];
 871
 872   return location;
 873 }
 874
 875 /* Return the source line number corresponding to source location
 876    LOCATION.  SET is the line map set LOCATION comes from.  If
 877    LOCATION is the source location of token that is part of the
 878    replacement-list of a macro expansion return the line number of the
 879    macro expansion point.  */
 880
 881 int
 882 linemap_get_expansion_line (struct line_maps *set,
 883                             source_location location)
 884 {
 885   const struct line_map *map = NULL;
 886
 887   if (IS_ADHOC_LOC (location))
 888     location = set->location_adhoc_data_map.data[location
 889                                                  & MAX_SOURCE_LOCATION].locus;
 890
 891   if (location < RESERVED_LOCATION_COUNT)
 892     return 0;
 893
 894   location =
 895     linemap_macro_loc_to_exp_point (set, location, &map);
 896
 897   return SOURCE_LINE (map, location);
 898 }
 899
 900 /* Return the path of the file corresponding to source code location
 901    LOCATION.
 902
 903    If LOCATION is the source location of token that is part of the
 904    replacement-list of a macro expansion return the file path of the
 905    macro expansion point.
 906
 907    SET is the line map set LOCATION comes from.  */
 908
 909 const char*
 910 linemap_get_expansion_filename (struct line_maps *set,
 911                                 source_location location)
 912 {
 913   const struct line_map *map = NULL;
 914
 915   if (IS_ADHOC_LOC (location))
 916     location = set->location_adhoc_data_map.data[location
 917                                                  & MAX_SOURCE_LOCATION].locus;
 918
 919   if (location < RESERVED_LOCATION_COUNT)
 920     return NULL;
 921
 922   location =
 923     linemap_macro_loc_to_exp_point (set, location, &map);
 924
 925   return LINEMAP_FILE (map);
 926 }
 927
 928 /* Return the name of the macro associated to MACRO_MAP.  */
 929
 930 const char*
 931 linemap_map_get_macro_name (const struct line_map* macro_map)
 932 {
 933   linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map));
 934   return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map));
 935 }
 936
 937 /* Return a positive value if LOCATION is the locus of a token that is
 938    located in a system header, O otherwise. It returns 1 if LOCATION
 939    is the locus of a token that is located in a system header, and 2
 940    if LOCATION is the locus of a token located in a C system header
 941    that therefore needs to be extern "C" protected in C++.
 942
 943    Note that this function returns 1 if LOCATION belongs to a token
 944    that is part of a macro replacement-list defined in a system
 945    header, but expanded in a non-system file.  */
 946
 947 int
 948 linemap_location_in_system_header_p (struct line_maps *set,
 949                                      source_location location)
 950 {
 951   const struct line_map *map = NULL;
 952
 953   if (IS_ADHOC_LOC (location))
 954     location = set->location_adhoc_data_map.data[location
 955                                                  & MAX_SOURCE_LOCATION].locus;
 956
 957   if (location < RESERVED_LOCATION_COUNT)
 958     return false;
 959
 960   /* Let's look at where the token for LOCATION comes from.  */
 961   while (true)
 962     {
 963       map = linemap_lookup (set, location);
 964       if (map != NULL)
 965         {
 966           if (!linemap_macro_expansion_map_p (map))
 967             /* It's a normal token.  */
 968             return LINEMAP_SYSP (map);
 969           else
 970             {
 971               /* It's a token resulting from a macro expansion.  */
 972               source_location loc =
 973                 linemap_macro_map_loc_unwind_toward_spelling (map, location);
 974               if (loc < RESERVED_LOCATION_COUNT)
 975                 /* This token might come from a built-in macro.  Let's
 976                    look at where that macro got expanded.  */
 977                 location = linemap_macro_map_loc_to_exp_point (map, location);
 978               else
 979                 location = loc;
 980             }
 981         }
 982       else
 983         break;
 984     }
 985   return false;
 986 }
 987
 988 /* Return TRUE if LOCATION is a source code location of a token coming
 989    from a macro replacement-list at a macro expansion point, FALSE
 990    otherwise.  */
 991
 992 bool
 993 linemap_location_from_macro_expansion_p (const struct line_maps *set,
 994                                          source_location location)
 995 {
 996   if (IS_ADHOC_LOC (location))
 997     location = set->location_adhoc_data_map.data[location
 998                                                  & MAX_SOURCE_LOCATION].locus;
 999
1000   linemap_assert (location <= MAX_SOURCE_LOCATION
1001                   && (set->highest_location
1002                       < LINEMAPS_MACRO_LOWEST_LOCATION (set)));
1003   if (set == NULL)
1004     return false;
1005   return (location > set->highest_location);
1006 }
1007
1008 /* Given two virtual locations *LOC0 and *LOC1, return the first
1009    common macro map in their macro expansion histories.  Return NULL
1010    if no common macro was found.  *LOC0 (resp. *LOC1) is set to the
1011    virtual location of the token inside the resulting macro.  */
1012
1013 static const struct line_map*
1014 first_map_in_common_1 (struct line_maps *set,
1015                        source_location *loc0,
1016                        source_location *loc1)
1017 {
1018   source_location l0 = *loc0, l1 = *loc1;
1019   const struct line_map *map0 = linemap_lookup (set, l0),
1020     *map1 = linemap_lookup (set, l1);
1021
1022   while (linemap_macro_expansion_map_p (map0)
1023          && linemap_macro_expansion_map_p (map1)
1024          && (map0 != map1))
1025     {
1026       if (MAP_START_LOCATION (map0) < MAP_START_LOCATION (map1))
1027         {
1028           l0 = linemap_macro_map_loc_to_exp_point (map0, l0);
1029           map0 = linemap_lookup (set, l0);
1030         }
1031       else
1032         {
1033           l1 = linemap_macro_map_loc_to_exp_point (map1, l1);
1034           map1 = linemap_lookup (set, l1);
1035         }
1036     }
1037
1038   if (map0 == map1)
1039     {
1040       *loc0 = l0;
1041       *loc1 = l1;
1042       return map0;
1043     }
1044   return NULL;
1045 }
1046
1047 /* Given two virtual locations LOC0 and LOC1, return the first common
1048    macro map in their macro expansion histories.  Return NULL if no
1049    common macro was found.  *RES_LOC0 (resp. *RES_LOC1) is set to the
1050    virtual location of the token inside the resulting macro, upon
1051    return of a non-NULL result.  */
1052
1053 static const struct line_map*
1054 first_map_in_common (struct line_maps *set,
1055                      source_location loc0,
1056                      source_location loc1,
1057                      source_location  *res_loc0,
1058                      source_location  *res_loc1)
1059 {
1060   *res_loc0 = loc0;
1061   *res_loc1 = loc1;
1062
1063   return first_map_in_common_1 (set, res_loc0, res_loc1);
1064 }
1065
1066 /* Return a positive value if PRE denotes the location of a token that
1067    comes before the token of POST, 0 if PRE denotes the location of
1068    the same token as the token for POST, and a negative value
1069    otherwise.  */
1070
1071 int
1072 linemap_compare_locations (struct line_maps *set,
1073                            source_location  pre,
1074                            source_location post)
1075 {
1076   bool pre_virtual_p, post_virtual_p;
1077   source_location l0 = pre, l1 = post;
1078
1079   if (IS_ADHOC_LOC (l0))
1080     l0 = set->location_adhoc_data_map.data[l0 & MAX_SOURCE_LOCATION].locus;
1081   if (IS_ADHOC_LOC (l1))
1082     l1 = set->location_adhoc_data_map.data[l1 & MAX_SOURCE_LOCATION].locus;
1083
1084   if (l0 == l1)
1085     return 0;
1086
1087   if ((pre_virtual_p = linemap_location_from_macro_expansion_p (set, l0)))
1088     l0 = linemap_resolve_location (set, l0,
1089                                    LRK_MACRO_EXPANSION_POINT,
1090                                    NULL);
1091
1092   if ((post_virtual_p = linemap_location_from_macro_expansion_p (set, l1)))
1093     l1 = linemap_resolve_location (set, l1,
1094                                    LRK_MACRO_EXPANSION_POINT,
1095                                    NULL);
1096
1097   if (l0 == l1
1098       && pre_virtual_p
1099       && post_virtual_p)
1100     {
1101       /* So pre and post represent two tokens that are present in a
1102          same macro expansion.  Let's see if the token for pre was
1103          before the token for post in that expansion.  */
1104       unsigned i0, i1;
1105       const struct line_map *map =
1106         first_map_in_common (set, pre, post, &l0, &l1);
1107
1108       if (map == NULL)
1109         /* This should not be possible.  */
1110         abort ();
1111
1112       i0 = l0 - MAP_START_LOCATION (map);
1113       i1 = l1 - MAP_START_LOCATION (map);
1114       return i1 - i0;
1115     }
1116
1117   return l1 - l0;
1118 }
1119
1120 /* Print an include trace, for e.g. the -H option of the preprocessor.  */
1121
1122 static void
1123 trace_include (const struct line_maps *set, const struct line_map *map)
1124 {
1125   unsigned int i = set->depth;
1126
1127   while (--i)
1128     putc ('.', stderr);
1129
1130   fprintf (stderr, " %s\n", ORDINARY_MAP_FILE_NAME (map));
1131 }
1132
1133 /* Return the spelling location of the token wherever it comes from,
1134    whether part of a macro definition or not.
1135
1136    This is a subroutine for linemap_resolve_location.  */
1137
1138 static source_location
1139 linemap_macro_loc_to_spelling_point (struct line_maps *set,
1140                                      source_location location,
1141                                      const struct line_map **original_map)
1142 {
1143   struct line_map *map;
1144
1145   if (IS_ADHOC_LOC (location))
1146     location = set->location_adhoc_data_map.data[location
1147                                                  & MAX_SOURCE_LOCATION].locus;
1148
1149   linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1150
1151   while (true)
1152     {
1153       map = (struct line_map*) linemap_lookup (set, location);
1154       if (!linemap_macro_expansion_map_p (map))
1155         break;
1156
1157       location =
1158         linemap_macro_map_loc_unwind_toward_spelling (map, location);
1159     }
1160
1161   if (original_map)
1162     *original_map = map;
1163   return location;
1164 }
1165
1166 /* If LOCATION is the source location of a token that belongs to a
1167    macro replacement-list -- as part of a macro expansion -- then
1168    return the location of the token at the definition point of the
1169    macro.  Otherwise, return LOCATION.  SET is the set of maps
1170    location come from.  ORIGINAL_MAP is an output parm. If non NULL,
1171    the function sets *ORIGINAL_MAP to the ordinary (non-macro) map the
1172    returned location comes from.
1173
1174    This is a subroutine of linemap_resolve_location.  */
1175
1176 static source_location
1177 linemap_macro_loc_to_def_point (struct line_maps *set,
1178                                 source_location location,
1179                                 const struct line_map **original_map)
1180 {
1181   struct line_map *map;
1182
1183   if (IS_ADHOC_LOC (location))
1184     location = set->location_adhoc_data_map.data[location
1185                                                  & MAX_SOURCE_LOCATION].locus;
1186
1187   linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1188
1189   while (true)
1190     {
1191       map = (struct line_map*) linemap_lookup (set, location);
1192       if (!linemap_macro_expansion_map_p (map))
1193         break;
1194
1195       location =
1196         linemap_macro_map_loc_to_def_point (map, location);
1197     }
1198
1199   if (original_map)
1200     *original_map = map;
1201   return location;
1202 }
1203
1204 /* If LOCATION is the source location of a token that belongs to a
1205    macro replacement-list -- at a macro expansion point -- then return
1206    the location of the topmost expansion point of the macro.  We say
1207    topmost because if we are in the context of a nested macro
1208    expansion, the function returns the source location of the first
1209    macro expansion that triggered the nested expansions.
1210
1211    Otherwise, return LOCATION.  SET is the set of maps location come
1212    from.  ORIGINAL_MAP is an output parm. If non NULL, the function
1213    sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
1214    location comes from.
1215
1216    This is a subroutine of linemap_resolve_location.  */
1217
1218 static source_location
1219 linemap_macro_loc_to_exp_point (struct line_maps *set,
1220                                 source_location location,
1221                                 const struct line_map **original_map)
1222 {
1223   struct line_map *map;
1224
1225   if (IS_ADHOC_LOC (location))
1226     location = set->location_adhoc_data_map.data[location
1227                                                  & MAX_SOURCE_LOCATION].locus;
1228
1229   linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
1230
1231   while (true)
1232     {
1233       map = (struct line_map*) linemap_lookup (set, location);
1234       if (!linemap_macro_expansion_map_p (map))
1235         break;
1236       location = linemap_macro_map_loc_to_exp_point (map, location);
1237     }
1238
1239   if (original_map)
1240     *original_map = map;
1241   return location;
1242 }
1243
1244 /* Resolve a virtual location into either a spelling location, an
1245    expansion point location or a token argument replacement point
1246    location.  Return the map that encodes the virtual location as well
1247    as the resolved location.
1248
1249    If LOC is *NOT* the location of a token resulting from the
1250    expansion of a macro, then the parameter LRK (which stands for
1251    Location Resolution Kind) is ignored and the resulting location
1252    just equals the one given in argument.
1253
1254    Now if LOC *IS* the location of a token resulting from the
1255    expansion of a macro, this is what happens.
1256
1257    * If LRK is set to LRK_MACRO_EXPANSION_POINT
1258    -------------------------------
1259
1260    The virtual location is resolved to the first macro expansion point
1261    that led to this macro expansion.
1262
1263    * If LRK is set to LRK_SPELLING_LOCATION
1264    -------------------------------------
1265
1266    The virtual location is resolved to the locus where the token has
1267    been spelled in the source.   This can follow through all the macro
1268    expansions that led to the token.
1269
1270    * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
1271    --------------------------------------
1272
1273    The virtual location is resolved to the locus of the token in the
1274    context of the macro definition.
1275
1276    If LOC is the locus of a token that is an argument of a
1277    function-like macro [replacing a parameter in the replacement list
1278    of the macro] the virtual location is resolved to the locus of the
1279    parameter that is replaced, in the context of the definition of the
1280    macro.
1281
1282    If LOC is the locus of a token that is not an argument of a
1283    function-like macro, then the function behaves as if LRK was set to
1284    LRK_SPELLING_LOCATION.
1285
1286    If MAP is not NULL, *MAP is set to the map encoding the
1287    returned location.  Note that if the returned location wasn't originally
1288    encoded by a map, then *MAP is set to NULL.  This can happen if LOC
1289    resolves to a location reserved for the client code, like
1290    UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC.  */
1291
1292 source_location
1293 linemap_resolve_location (struct line_maps *set,
1294                           source_location loc,
1295                           enum location_resolution_kind lrk,
1296                           const struct line_map **map)
1297 {
1298   if (IS_ADHOC_LOC (loc))
1299     loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1300
1301   if (loc < RESERVED_LOCATION_COUNT)
1302     {
1303       /* A reserved location wasn't encoded in a map.  Let's return a
1304          NULL map here, just like what linemap_ordinary_map_lookup
1305          does.  */
1306       if (map)
1307         *map = NULL;
1308       return loc;
1309     }
1310
1311   switch (lrk)
1312     {
1313     case LRK_MACRO_EXPANSION_POINT:
1314       loc = linemap_macro_loc_to_exp_point (set, loc, map);
1315       break;
1316     case LRK_SPELLING_LOCATION:
1317       loc = linemap_macro_loc_to_spelling_point (set, loc, map);
1318       break;
1319     case LRK_MACRO_DEFINITION_LOCATION:
1320       loc = linemap_macro_loc_to_def_point (set, loc, map);
1321       break;
1322     default:
1323       abort ();
1324     }
1325   return loc;
1326 }
1327
1328 /*
1329    Suppose that LOC is the virtual location of a token T coming from
1330    the expansion of a macro M.  This function then steps up to get the
1331    location L of the point where M got expanded.  If L is a spelling
1332    location inside a macro expansion M', then this function returns
1333    the locus of the point where M' was expanded.  Said otherwise, this
1334    function returns the location of T in the context that triggered
1335    the expansion of M.
1336
1337    *LOC_MAP must be set to the map of LOC.  This function then sets it
1338    to the map of the returned location.  */
1339
1340 source_location
1341 linemap_unwind_toward_expansion (struct line_maps *set,
1342                                  source_location loc,
1343                                  const struct line_map **map)
1344 {
1345   source_location resolved_location;
1346   const struct line_map *resolved_map;
1347
1348   if (IS_ADHOC_LOC (loc))
1349     loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1350
1351   resolved_location =
1352     linemap_macro_map_loc_unwind_toward_spelling (*map, loc);
1353   resolved_map = linemap_lookup (set, resolved_location);
1354
1355   if (!linemap_macro_expansion_map_p (resolved_map))
1356     {
1357       resolved_location = linemap_macro_map_loc_to_exp_point (*map, loc);
1358       resolved_map = linemap_lookup (set, resolved_location);
1359     }
1360
1361   *map = resolved_map;
1362   return resolved_location;
1363 }
1364
1365 /* If LOC is the virtual location of a token coming from the expansion
1366    of a macro M and if its spelling location is reserved (e.g, a
1367    location for a built-in token), then this function unwinds (using
1368    linemap_unwind_toward_expansion) the location until a location that
1369    is not reserved and is not in a system header is reached.  In other
1370    words, this unwinds the reserved location until a location that is
1371    in real source code is reached.
1372
1373    Otherwise, if the spelling location for LOC is not reserved or if
1374    LOC doesn't come from the expansion of a macro, the function
1375    returns LOC as is and *MAP is not touched.
1376
1377    *MAP is set to the map of the returned location if the later is
1378    different from LOC.  */
1379 source_location
1380 linemap_unwind_to_first_non_reserved_loc (struct line_maps *set,
1381                                           source_location loc,
1382                                           const struct line_map **map)
1383 {
1384   source_location resolved_loc;
1385   const struct line_map *map0 = NULL, *map1 = NULL;
1386
1387   if (IS_ADHOC_LOC (loc))
1388     loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1389
1390   map0 = linemap_lookup (set, loc);
1391   if (!linemap_macro_expansion_map_p (map0))
1392     return loc;
1393
1394   resolved_loc = linemap_resolve_location (set, loc,
1395                                            LRK_SPELLING_LOCATION,
1396                                            &map1);
1397
1398   if (resolved_loc >= RESERVED_LOCATION_COUNT
1399       && !LINEMAP_SYSP (map1))
1400     return loc;
1401
1402   while (linemap_macro_expansion_map_p (map0)
1403          && (resolved_loc < RESERVED_LOCATION_COUNT
1404              || LINEMAP_SYSP (map1)))
1405     {
1406       loc = linemap_unwind_toward_expansion (set, loc, &map0);
1407       resolved_loc = linemap_resolve_location (set, loc,
1408                                                LRK_SPELLING_LOCATION,
1409                                                &map1);
1410     }
1411
1412   if (map != NULL)
1413     *map = map0;
1414   return loc;
1415 }
1416
1417 /* Expand source code location LOC and return a user readable source
1418    code location.  LOC must be a spelling (non-virtual) location.  If
1419    it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
1420    location is returned.  */
1421
1422 expanded_location
1423 linemap_expand_location (struct line_maps *set,
1424                          const struct line_map *map,
1425                          source_location loc)
1426
1427 {
1428   expanded_location xloc;
1429
1430   memset (&xloc, 0, sizeof (xloc));
1431   if (IS_ADHOC_LOC (loc))
1432     {
1433       loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1434       xloc.data
1435         = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].data;
1436     }
1437
1438   if (loc < RESERVED_LOCATION_COUNT)
1439     /* The location for this token wasn't generated from a line map.
1440        It was probably a location for a builtin token, chosen by some
1441        client code.  Let's not try to expand the location in that
1442        case.  */;
1443   else if (map == NULL)
1444     /* We shouldn't be getting a NULL map with a location that is not
1445        reserved by the client code.  */
1446     abort ();
1447   else
1448     {
1449       /* MAP must be an ordinary map and LOC must be non-virtual,
1450          encoded into this map, obviously; the accessors used on MAP
1451          below ensure it is ordinary.  Let's just assert the
1452          non-virtualness of LOC here.  */
1453       if (linemap_location_from_macro_expansion_p (set, loc))
1454         abort ();
1455
1456       xloc.file = LINEMAP_FILE (map);
1457       xloc.line = SOURCE_LINE (map, loc);
1458       xloc.column = SOURCE_COLUMN (map, loc);
1459       xloc.sysp = LINEMAP_SYSP (map) != 0;
1460     }
1461
1462   return xloc;
1463 }
1464
1465
1466 /* Dump line map at index IX in line table SET to STREAM.  If STREAM
1467    is NULL, use stderr.  IS_MACRO is true if the caller wants to
1468    dump a macro map, false otherwise.  */
1469
1470 void
1471 linemap_dump (FILE *stream, struct line_maps *set, unsigned ix, bool is_macro)
1472 {
1473   const char *lc_reasons_v[LC_ENTER_MACRO + 1]
1474       = { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
1475           "LC_ENTER_MACRO" };
1476   const char *reason;
1477   struct line_map *map;
1478
1479   if (stream == NULL)
1480     stream = stderr;
1481
1482   if (!is_macro)
1483     map = LINEMAPS_ORDINARY_MAP_AT (set, ix);
1484   else
1485     map = LINEMAPS_MACRO_MAP_AT (set, ix);
1486
1487   reason = (map->reason <= LC_ENTER_MACRO) ? lc_reasons_v[map->reason] : "???";
1488
1489   fprintf (stream, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
1490            ix, (void *) map, map->start_location, reason,
1491            (!is_macro && ORDINARY_MAP_IN_SYSTEM_HEADER_P (map)) ? "yes" : "no");
1492   if (!is_macro)
1493     {
1494       unsigned includer_ix;
1495       struct line_map *includer_map;
1496
1497       includer_ix = ORDINARY_MAP_INCLUDER_FILE_INDEX (map);
1498       includer_map = includer_ix < LINEMAPS_ORDINARY_USED (set)
1499                      ? LINEMAPS_ORDINARY_MAP_AT (set, includer_ix)
1500                      : NULL;
1501
1502       fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (map),
1503                ORDINARY_MAP_STARTING_LINE_NUMBER (map));
1504       fprintf (stream, "Included from: [%d] %s\n", includer_ix,
1505                includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None");
1506     }
1507   else
1508     fprintf (stream, "Macro: %s (%u tokens)\n",
1509              linemap_map_get_macro_name (map),
1510              MACRO_MAP_NUM_MACRO_TOKENS (map));
1511
1512   fprintf (stream, "\n");
1513 }
1514
1515
1516 /* Dump debugging information about source location LOC into the file
1517    stream STREAM. SET is the line map set LOC comes from.  */
1518
1519 void
1520 linemap_dump_location (struct line_maps *set,
1521                        source_location loc,
1522                        FILE *stream)
1523 {
1524   const struct line_map *map;
1525   source_location location;
1526   const char *path = "", *from = "";
1527   int l = -1, c = -1, s = -1, e = -1;
1528
1529   if (IS_ADHOC_LOC (loc))
1530     loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
1531
1532   if (loc == 0)
1533     return;
1534
1535   location =
1536     linemap_resolve_location (set, loc, LRK_MACRO_DEFINITION_LOCATION, &map);
1537
1538   if (map == NULL)
1539     /* Only reserved locations can be tolerated in this case.  */
1540     linemap_assert (location < RESERVED_LOCATION_COUNT);
1541   else
1542     {
1543       path = LINEMAP_FILE (map);
1544       l = SOURCE_LINE (map, location);
1545       c = SOURCE_COLUMN (map, location);
1546       s = LINEMAP_SYSP (map) != 0;
1547       e = location != loc;
1548       if (e)
1549         from = "N/A";
1550       else
1551         from = (INCLUDED_FROM (set, map))
1552           ? LINEMAP_FILE (INCLUDED_FROM (set, map))
1553           : "<NULL>";
1554     }
1555
1556   /* P: path, L: line, C: column, S: in-system-header, M: map address,
1557      E: macro expansion?, LOC: original location, R: resolved location   */
1558   fprintf (stream, "{P:%s;F:%s;L:%d;C:%d;S:%d;M:%p;E:%d,LOC:%d,R:%d}",
1559            path, from, l, c, s, (void*)map, e, loc, location);
1560 }
1561
1562 /* Return the highest location emitted for a given file for which
1563    there is a line map in SET.  FILE_NAME is the file name to
1564    consider.  If the function returns TRUE, *LOC is set to the highest
1565    location emitted for that file.  */
1566
1567 bool
1568 linemap_get_file_highest_location (struct line_maps *set,
1569                                    const char *file_name,
1570                                    source_location *loc)
1571 {
1572   /* If the set is empty or no ordinary map has been created then
1573      there is no file to look for ...  */
1574   if (set == NULL || set->info_ordinary.used == 0)
1575     return false;
1576
1577   /* Now look for the last ordinary map created for FILE_NAME.  */
1578   int i;
1579   for (i = set->info_ordinary.used - 1; i >= 0; --i)
1580     {
1581       const char *fname = set->info_ordinary.maps[i].d.ordinary.to_file;
1582       if (fname && !filename_cmp (fname, file_name))
1583         break;
1584     }
1585
1586   if (i < 0)
1587     return false;
1588
1589   /* The highest location for a given map is either the starting
1590      location of the next map minus one, or -- if the map is the
1591      latest one -- the highest location of the set.  */
1592   source_location result;
1593   if (i == (int) set->info_ordinary.used - 1)
1594     result = set->highest_location;
1595   else
1596     result = set->info_ordinary.maps[i + 1].start_location - 1;
1597
1598   *loc = result;
1599   return true;
1600 }
1601
1602 /* Compute and return statistics about the memory consumption of some
1603    parts of the line table SET.  */
1604
1605 void
1606 linemap_get_statistics (struct line_maps *set,
1607                         struct linemap_stats *s)
1608 {
1609   long ordinary_maps_allocated_size, ordinary_maps_used_size,
1610     macro_maps_allocated_size, macro_maps_used_size,
1611     macro_maps_locations_size = 0, duplicated_macro_maps_locations_size = 0;
1612
1613   struct line_map *cur_map;
1614
1615   ordinary_maps_allocated_size =
1616     LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map);
1617
1618   ordinary_maps_used_size =
1619     LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map);
1620
1621   macro_maps_allocated_size =
1622     LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map);
1623
1624   for (cur_map = LINEMAPS_MACRO_MAPS (set);
1625        cur_map && cur_map <= LINEMAPS_LAST_MACRO_MAP (set);
1626        ++cur_map)
1627     {
1628       unsigned i;
1629
1630       linemap_assert (linemap_macro_expansion_map_p (cur_map));
1631
1632       macro_maps_locations_size +=
1633         2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map) * sizeof (source_location);
1634
1635       for (i = 0; i < 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map); i += 2)
1636         {
1637           if (MACRO_MAP_LOCATIONS (cur_map)[i] ==
1638               MACRO_MAP_LOCATIONS (cur_map)[i + 1])
1639             duplicated_macro_maps_locations_size +=
1640               sizeof (source_location);
1641         }
1642     }
1643
1644   macro_maps_used_size =
1645     LINEMAPS_MACRO_USED (set) * sizeof (struct line_map);
1646
1647   s->num_ordinary_maps_allocated = LINEMAPS_ORDINARY_ALLOCATED (set);
1648   s->num_ordinary_maps_used = LINEMAPS_ORDINARY_USED (set);
1649   s->ordinary_maps_allocated_size = ordinary_maps_allocated_size;
1650   s->ordinary_maps_used_size = ordinary_maps_used_size;
1651   s->num_expanded_macros = num_expanded_macros_counter;
1652   s->num_macro_tokens = num_macro_tokens_counter;
1653   s->num_macro_maps_used = LINEMAPS_MACRO_USED (set);
1654   s->macro_maps_allocated_size = macro_maps_allocated_size;
1655   s->macro_maps_locations_size = macro_maps_locations_size;
1656   s->macro_maps_used_size = macro_maps_used_size;
1657   s->duplicated_macro_maps_locations_size =
1658     duplicated_macro_maps_locations_size;
1659 }
1660
1661
1662 /* Dump line table SET to STREAM.  If STREAM is NULL, stderr is used.
1663    NUM_ORDINARY specifies how many ordinary maps to dump.  NUM_MACRO
1664    specifies how many macro maps to dump.  */
1665
1666 void
1667 line_table_dump (FILE *stream, struct line_maps *set, unsigned int num_ordinary,
1668                  unsigned int num_macro)
1669 {
1670   unsigned int i;
1671
1672   if (set == NULL)
1673     return;
1674
1675   if (stream == NULL)
1676     stream = stderr;
1677
1678   fprintf (stream, "# of ordinary maps:  %d\n", LINEMAPS_ORDINARY_USED (set));
1679   fprintf (stream, "# of macro maps:     %d\n", LINEMAPS_MACRO_USED (set));
1680   fprintf (stream, "Include stack depth: %d\n", set->depth);
1681   fprintf (stream, "Highest location:    %u\n", set->highest_location);
1682
1683   if (num_ordinary)
1684     {
1685       fprintf (stream, "\nOrdinary line maps\n");
1686       for (i = 0; i < num_ordinary && i < LINEMAPS_ORDINARY_USED (set); i++)
1687         linemap_dump (stream, set, i, false);
1688       fprintf (stream, "\n");
1689     }
1690
1691   if (num_macro)
1692     {
1693       fprintf (stream, "\nMacro line maps\n");
1694       for (i = 0; i < num_macro && i < LINEMAPS_MACRO_USED (set); i++)
1695         linemap_dump (stream, set, i, true);
1696       fprintf (stream, "\n");
1697     }
1698 }