static const struct line_map*
first_map_in_common_1 (struct line_maps *set,
source_location *loc0,
source_location *loc1)
{
source_location l0 = *loc0, l1 = *loc1;
const struct line_map *map0 = linemap_lookup (set, l0),
*map1 = linemap_lookup (set, l1);
while (linemap_macro_expansion_map_p (map0)
&& linemap_macro_expansion_map_p (map1)
&& (map0 != map1))
{
if (MAP_START_LOCATION (map0) < MAP_START_LOCATION (map1))
{
l0 = linemap_macro_map_loc_to_exp_point (map0, l0);
map0 = linemap_lookup (set, l0);
}
else
{
l1 = linemap_macro_map_loc_to_exp_point (map1, l1);
map1 = linemap_lookup (set, l1);
}
}
if (map0 == map1)
{
*loc0 = l0;
*loc1 = l1;
return map0;
}
return NULL;
}
/* If LOC is the virtual location of a token coming from the expansion
of a macro M and if its spelling location is reserved (e.g, a
location for a built-in token), then this function unwinds (using
linemap_unwind_toward_expansion) the location until a location that
is not reserved and is not in a system header is reached. In other
words, this unwinds the reserved location until a location that is
in real source code is reached.
Otherwise, if the spelling location for LOC is not reserved or if
LOC doesn't come from the expansion of a macro, the function
returns LOC as is and *MAP is not touched.
*MAP is set to the map of the returned location if the later is
different from LOC. */
source_location
linemap_unwind_to_first_non_reserved_loc (struct line_maps *set,
source_location loc,
const struct line_map **map)
{
source_location resolved_loc;
const struct line_map *map0 = NULL, *map1 = NULL;
map0 = linemap_lookup (set, loc);
if (!linemap_macro_expansion_map_p (map0))
return loc;
resolved_loc = linemap_resolve_location (set, loc,
LRK_SPELLING_LOCATION,
&map1);
if (resolved_loc >= RESERVED_LOCATION_COUNT
&& !LINEMAP_SYSP (map1))
return loc;
while (linemap_macro_expansion_map_p (map0)
&& (resolved_loc < RESERVED_LOCATION_COUNT
|| LINEMAP_SYSP (map1)))
{
loc = linemap_unwind_toward_expansion (set, loc, &map0);
resolved_loc = linemap_resolve_location (set, loc,
LRK_SPELLING_LOCATION,
&map1);
}
if (map != NULL)
*map = map0;
return loc;
}
source_location
linemap_position_for_column (struct line_maps *set, unsigned int to_column)
{
source_location r = set->highest_line;
linemap_assert
(!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
if (to_column >= set->max_column_hint)
{
if (r >= 0xC000000 || to_column > 100000)
{
/* Running low on source_locations - disable column numbers. */
return r;
}
else
{
struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
}
}
r = r + to_column;
if (r >= set->highest_location)
set->highest_location = r;
return r;
}
void
linemap_get_statistics (struct line_maps *set,
struct linemap_stats *s)
{
long ordinary_maps_allocated_size, ordinary_maps_used_size,
macro_maps_allocated_size, macro_maps_used_size,
macro_maps_locations_size = 0, duplicated_macro_maps_locations_size = 0;
struct line_map *cur_map;
ordinary_maps_allocated_size =
LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map);
ordinary_maps_used_size =
LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map);
macro_maps_allocated_size =
LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map);
for (cur_map = LINEMAPS_MACRO_MAPS (set);
cur_map && cur_map <= LINEMAPS_LAST_MACRO_MAP (set);
++cur_map)
{
unsigned i;
linemap_assert (linemap_macro_expansion_map_p (cur_map));
macro_maps_locations_size +=
2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map) * sizeof (source_location);
for (i = 0; i < 2 * MACRO_MAP_NUM_MACRO_TOKENS (cur_map); i += 2)
{
if (MACRO_MAP_LOCATIONS (cur_map)[i] ==
MACRO_MAP_LOCATIONS (cur_map)[i + 1])
duplicated_macro_maps_locations_size +=
sizeof (source_location);
}
}
macro_maps_used_size =
LINEMAPS_MACRO_USED (set) * sizeof (struct line_map);
s->num_ordinary_maps_allocated = LINEMAPS_ORDINARY_ALLOCATED (set);
s->num_ordinary_maps_used = LINEMAPS_ORDINARY_USED (set);
s->ordinary_maps_allocated_size = ordinary_maps_allocated_size;
s->ordinary_maps_used_size = ordinary_maps_used_size;
s->num_expanded_macros = num_expanded_macros_counter;
s->num_macro_tokens = num_macro_tokens_counter;
s->num_macro_maps_used = LINEMAPS_MACRO_USED (set);
s->macro_maps_allocated_size = macro_maps_allocated_size;
s->macro_maps_locations_size = macro_maps_locations_size;
s->macro_maps_used_size = macro_maps_used_size;
s->duplicated_macro_maps_locations_size =
duplicated_macro_maps_locations_size;
}
static source_location
linemap_macro_map_loc_to_exp_point (const struct line_map *map,
source_location location ATTRIBUTE_UNUSED)
{
linemap_assert (linemap_macro_expansion_map_p (map)
&& location >= MAP_START_LOCATION (map));
/* Make sure LOCATION is correct. */
linemap_assert ((location - MAP_START_LOCATION (map))
< MACRO_MAP_NUM_MACRO_TOKENS (map));
return MACRO_MAP_EXPANSION_POINT_LOCATION (map);
}
/* If LOCATION is the locus of a token that is an argument of a
function-like macro M and appears in the expansion of M, return the
locus of that argument in the context of the caller of M.
In other words, this returns the xI location presented in the
comments of line_map_macro above. */
source_location
linemap_macro_map_loc_unwind_toward_spelling (const struct line_map* map,
source_location location)
{
unsigned token_no;
linemap_assert (linemap_macro_expansion_map_p (map)
&& location >= MAP_START_LOCATION (map));
linemap_assert (location >= RESERVED_LOCATION_COUNT);
token_no = location - MAP_START_LOCATION (map);
linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
location = MACRO_MAP_LOCATIONS (map)[2 * token_no];
return location;
}
source_location
linemap_add_macro_token (const struct line_map *map,
unsigned int token_no,
source_location orig_loc,
source_location orig_parm_replacement_loc)
{
source_location result;
linemap_assert (linemap_macro_expansion_map_p (map));
linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
MACRO_MAP_LOCATIONS (map)[2 * token_no] = orig_loc;
MACRO_MAP_LOCATIONS (map)[2 * token_no + 1] = orig_parm_replacement_loc;
result = MAP_START_LOCATION (map) + token_no;
return result;
}
static source_location
linemap_macro_loc_to_exp_point (struct line_maps *set,
source_location location,
const struct line_map **original_map)
{
struct line_map *map;
linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
while (true)
{
map = (struct line_map*) linemap_lookup (set, location);
if (!linemap_macro_expansion_map_p (map))
break;
location = linemap_macro_map_loc_to_exp_point (map, location);
}
if (original_map)
*original_map = map;
return location;
}
source_location
linemap_unwind_toward_expansion (struct line_maps *set,
source_location loc,
const struct line_map **map)
{
source_location resolved_location;
const struct line_map *resolved_map;
resolved_location =
linemap_macro_map_loc_unwind_toward_spelling (*map, loc);
resolved_map = linemap_lookup (set, resolved_location);
if (!linemap_macro_expansion_map_p (resolved_map))
{
resolved_location = linemap_macro_map_loc_to_exp_point (*map, loc);
resolved_map = linemap_lookup (set, resolved_location);
}
*map = resolved_map;
return resolved_location;
}
int
linemap_location_in_system_header_p (struct line_maps *set,
source_location location)
{
const struct line_map *map = NULL;
if (location < RESERVED_LOCATION_COUNT)
return false;
/* Let's look at where the token for LOCATION comes from. */
while (true)
{
map = linemap_lookup (set, location);
if (map != NULL)
{
if (!linemap_macro_expansion_map_p (map))
/* It's a normal token. */
return LINEMAP_SYSP (map);
else
{
/* It's a token resulting from a macro expansion. */
source_location loc =
linemap_macro_map_loc_unwind_toward_spelling (map, location);
if (loc < RESERVED_LOCATION_COUNT)
/* This token might come from a built-in macro. Let's
look at where that macro got expanded. */
location = linemap_macro_map_loc_to_exp_point (map, location);
else
location = loc;
}
}
else
break;
}
return false;
}
const char*
linemap_map_get_macro_name (const struct line_map* macro_map)
{
linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map));
return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map));
}
