| /* Data and functions related to line maps and input files. |
| Copyright (C) 2004, 2007, 2008, 2009, 2010, 2011 |
| Free Software Foundation, Inc. |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "intl.h" |
| #include "input.h" |
| |
| /* Current position in real source file. */ |
| |
| location_t input_location; |
| |
| struct line_maps *line_table; |
| |
| /* Expand the source location LOC into a human readable location. If |
| LOC resolves to a builtin location, the file name of the readable |
| location is set to the string "<built-in>". */ |
| |
| expanded_location |
| expand_location (source_location loc) |
| { |
| expanded_location xloc; |
| const struct line_map *map; |
| |
| loc = linemap_resolve_location (line_table, loc, |
| LRK_SPELLING_LOCATION, &map); |
| xloc = linemap_expand_location (line_table, map, loc); |
| |
| if (loc <= BUILTINS_LOCATION) |
| xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>"); |
| |
| return xloc; |
| } |
| |
| #define ONE_K 1024 |
| #define ONE_M (ONE_K * ONE_K) |
| |
| /* Display a number as an integer multiple of either: |
| - 1024, if said integer is >= to 10 K (in base 2) |
| - 1024 * 1024, if said integer is >= 10 M in (base 2) |
| */ |
| #define SCALE(x) ((unsigned long) ((x) < 10 * ONE_K \ |
| ? (x) \ |
| : ((x) < 10 * ONE_M \ |
| ? (x) / ONE_K \ |
| : (x) / ONE_M))) |
| |
| /* For a given integer, display either: |
| - the character 'k', if the number is higher than 10 K (in base 2) |
| but strictly lower than 10 M (in base 2) |
| - the character 'M' if the number is higher than 10 M (in base2) |
| - the charcter ' ' if the number is strictly lower than 10 K */ |
| #define STAT_LABEL(x) ((x) < 10 * ONE_K ? ' ' : ((x) < 10 * ONE_M ? 'k' : 'M')) |
| |
| /* Display an integer amount as multiple of 1K or 1M (in base 2). |
| Display the correct unit (either k, M, or ' ') after the amout, as |
| well. */ |
| #define FORMAT_AMOUNT(size) SCALE (size), STAT_LABEL (size) |
| |
| /* Dump statistics to stderr about the memory usage of the line_table |
| set of line maps. This also displays some statistics about macro |
| expansion. */ |
| |
| void |
| dump_line_table_statistics (void) |
| { |
| struct linemap_stats s; |
| long total_used_map_size, |
| macro_maps_size, |
| total_allocated_map_size; |
| |
| memset (&s, 0, sizeof (s)); |
| |
| linemap_get_statistics (line_table, &s); |
| |
| macro_maps_size = s.macro_maps_used_size |
| + s.macro_maps_locations_size; |
| |
| total_allocated_map_size = s.ordinary_maps_allocated_size |
| + s.macro_maps_allocated_size |
| + s.macro_maps_locations_size; |
| |
| total_used_map_size = s.ordinary_maps_used_size |
| + s.macro_maps_used_size |
| + s.macro_maps_locations_size; |
| |
| fprintf (stderr, "Number of expanded macros: %5ld\n", |
| s.num_expanded_macros); |
| if (s.num_expanded_macros != 0) |
| fprintf (stderr, "Average number of tokens per macro expansion: %5ld\n", |
| s.num_macro_tokens / s.num_expanded_macros); |
| fprintf (stderr, |
| "\nLine Table allocations during the " |
| "compilation process\n"); |
| fprintf (stderr, "Number of ordinary maps used: %5ld%c\n", |
| SCALE (s.num_ordinary_maps_used), |
| STAT_LABEL (s.num_ordinary_maps_used)); |
| fprintf (stderr, "Ordinary map used size: %5ld%c\n", |
| SCALE (s.ordinary_maps_used_size), |
| STAT_LABEL (s.ordinary_maps_used_size)); |
| fprintf (stderr, "Number of ordinary maps allocated: %5ld%c\n", |
| SCALE (s.num_ordinary_maps_allocated), |
| STAT_LABEL (s.num_ordinary_maps_allocated)); |
| fprintf (stderr, "Ordinary maps allocated size: %5ld%c\n", |
| SCALE (s.ordinary_maps_allocated_size), |
| STAT_LABEL (s.ordinary_maps_allocated_size)); |
| fprintf (stderr, "Number of macro maps used: %5ld%c\n", |
| SCALE (s.num_macro_maps_used), |
| STAT_LABEL (s.num_macro_maps_used)); |
| fprintf (stderr, "Macro maps used size: %5ld%c\n", |
| SCALE (s.macro_maps_used_size), |
| STAT_LABEL (s.macro_maps_used_size)); |
| fprintf (stderr, "Macro maps locations size: %5ld%c\n", |
| SCALE (s.macro_maps_locations_size), |
| STAT_LABEL (s.macro_maps_locations_size)); |
| fprintf (stderr, "Macro maps size: %5ld%c\n", |
| SCALE (macro_maps_size), |
| STAT_LABEL (macro_maps_size)); |
| fprintf (stderr, "Duplicated maps locations size: %5ld%c\n", |
| SCALE (s.duplicated_macro_maps_locations_size), |
| STAT_LABEL (s.duplicated_macro_maps_locations_size)); |
| fprintf (stderr, "Total allocated maps size: %5ld%c\n", |
| SCALE (total_allocated_map_size), |
| STAT_LABEL (total_allocated_map_size)); |
| fprintf (stderr, "Total used maps size: %5ld%c\n", |
| SCALE (total_used_map_size), |
| STAT_LABEL (total_used_map_size)); |
| fprintf (stderr, "\n"); |
| } |