libcpp/line-map.c

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