+2015-05-19 David Malcolm <dmalcolm@redhat.com>
+
+ * diagnostic.c (diagnostic_report_current_module): Strengthen
+ local "new_map" from const line_map * to
+ const line_map_ordinary *.
+ * genmatch.c (error_cb): Likewise for local "map".
+ (output_line_directive): Likewise for local "map".
+ * input.c (expand_location_1): Likewise for local "map".
+ Pass NULL rather than &map to
+ linemap_unwind_to_first_non_reserved_loc, since the value is never
+ read from there, and the value written back not read from here.
+ (is_location_from_builtin_token): Strengthen local "map" from
+ const line_map * to const line_map_ordinary *.
+ (dump_location_info): Strengthen locals "map" from
+ line_map *, one to const line_map_ordinary *, the other
+ to const line_map_macro *.
+ * tree-diagnostic.c (loc_map_pair): Strengthen field "map" from
+ const line_map * to const line_map_macro *.
+ (maybe_unwind_expanded_macro_loc): Add a call to
+ linemap_check_macro when writing to the "map" field of the
+ loc_map_pair.
+ Introduce local const line_map_ordinary * "ord_map", using it in
+ place of "map" in the part of the function where we know we have
+ an ordinary map. Strengthen local "m" from const line_map * to
+ const line_map_ordinary *.
+
2015-05-19 Nick Clifton <nickc@redhat.com>
PR target/66156
+2015-05-19 David Malcolm <dmalcolm@redhat.com>
+
+ * gcc-interface/trans.c (Sloc_to_locus1): Strenghthen local "map"
+ from line_map * to line_map_ordinary *.
+
2015-05-12 Jason Merrill <jason@redhat.com>
* sigtramp-vxworks.c: Add space between string literal and macro
Source_File_Index file = Get_Source_File_Index (Sloc);
Logical_Line_Number line = Get_Logical_Line_Number (Sloc);
Column_Number column = (clear_column ? 0 : Get_Column_Number (Sloc));
- struct line_map *map = LINEMAPS_ORDINARY_MAP_AT (line_table, file - 1);
+ line_map_ordinary *map = LINEMAPS_ORDINARY_MAP_AT (line_table, file - 1);
/* We can have zero if pragma Source_Reference is in effect. */
if (line < 1)
+2015-05-19 David Malcolm <dmalcolm@redhat.com>
+
+ * c-common.h (fe_file_change): Strengthen param from
+ const line_map * to const line_map_ordinary *.
+ (pp_file_change): Likewise.
+ * c-lex.c (fe_file_change): Likewise.
+ (cb_define): Use linemap_check_ordinary when invoking
+ SOURCE_LINE.
+ (cb_undef): Likewise.
+ * c-opts.c (c_finish_options): Use linemap_check_ordinary when
+ invoking cb_file_change.
+ (c_finish_options): Likewise.
+ (push_command_line_include): Likewise.
+ (cb_file_change): Strengthen param "new_map" from
+ const line_map * to const line_map_ordinary *.
+ * c-ppoutput.c (cb_define): Likewise for local "map".
+ (pp_file_change): Likewise for param "map" and local "from".
+
2015-05-19 Mikhail Maltsev <maltsevm@gmail.com>
* c-common.c (shorten_compare): Use std::swap instead of explicit swaps.
extern void builtin_define_std (const char *macro);
extern void builtin_define_with_value (const char *, const char *, int);
extern void c_stddef_cpp_builtins (void);
-extern void fe_file_change (const struct line_map *);
+extern void fe_file_change (const line_map_ordinary *);
extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char);
/* In c-ppoutput.c */
extern void init_pp_output (FILE *);
extern void preprocess_file (cpp_reader *);
-extern void pp_file_change (const struct line_map *);
+extern void pp_file_change (const line_map_ordinary *);
extern void pp_dir_change (cpp_reader *, const char *);
extern bool check_missing_format_attribute (tree, tree);
}
void
-fe_file_change (const struct line_map *new_map)
+fe_file_change (const line_map_ordinary *new_map)
{
if (new_map == NULL)
return;
cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
{
const struct line_map *map = linemap_lookup (line_table, loc);
- (*debug_hooks->define) (SOURCE_LINE (map, loc),
+ (*debug_hooks->define) (SOURCE_LINE (linemap_check_ordinary (map), loc),
(const char *) cpp_macro_definition (pfile, node));
}
cpp_hashnode *node)
{
const struct line_map *map = linemap_lookup (line_table, loc);
- (*debug_hooks->undef) (SOURCE_LINE (map, loc),
+ (*debug_hooks->undef) (SOURCE_LINE (linemap_check_ordinary (map), loc),
(const char *) NODE_NAME (node));
}
static void sanitize_cpp_opts (void);
static void add_prefixed_path (const char *, size_t);
static void push_command_line_include (void);
-static void cb_file_change (cpp_reader *, const struct line_map *);
+static void cb_file_change (cpp_reader *, const line_map_ordinary *);
static void cb_dir_change (cpp_reader *, const char *);
static void c_finish_options (void);
size_t i;
cb_file_change (parse_in,
- linemap_add (line_table, LC_RENAME, 0,
- _("<built-in>"), 0));
+ linemap_check_ordinary (linemap_add (line_table,
+ LC_RENAME, 0,
+ _("<built-in>"),
+ 0)));
/* Make sure all of the builtins about to be declared have
BUILTINS_LOCATION has their source_location. */
source_location builtins_loc = BUILTINS_LOCATION;
cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99);
cb_file_change (parse_in,
- linemap_add (line_table, LC_RENAME, 0,
- _("<command-line>"), 0));
+ linemap_check_ordinary (linemap_add (line_table, LC_RENAME, 0,
+ _("<command-line>"), 0)));
for (i = 0; i < deferred_count; i++)
{
/* File change callback. Has to handle -include files. */
static void
cb_file_change (cpp_reader * ARG_UNUSED (pfile),
- const struct line_map *new_map)
+ const line_map_ordinary *new_map)
{
if (flag_preprocess_only)
pp_file_change (new_map);
static void
cb_define (cpp_reader *pfile, source_location line, cpp_hashnode *node)
{
- const struct line_map *map;
+ const line_map_ordinary *map;
maybe_print_line (line);
fputs ("#define ", print.outf);
described in MAP. */
void
-pp_file_change (const struct line_map *map)
+pp_file_change (const line_map_ordinary *map)
{
const char *flags = "";
/* Bring current file to correct line when entering a new file. */
if (map->reason == LC_ENTER)
{
- const struct line_map *from = INCLUDED_FROM (line_table, map);
+ const line_map_ordinary *from = INCLUDED_FROM (line_table, map);
maybe_print_line (LAST_SOURCE_LINE_LOCATION (from));
}
if (map->reason == LC_ENTER)
void
diagnostic_report_current_module (diagnostic_context *context, location_t where)
{
- const struct line_map *map = NULL;
+ const line_map_ordinary *map = NULL;
if (pp_needs_newline (context->printer))
{
+2015-05-19 David Malcolm <dmalcolm@redhat.com>
+
+ * cpp.c (maybe_print_line): Strengthen local "map" from
+ const line_map * to const line_map_ordinary *.
+ (cb_file_change): Likewise for param "map" and local "from".
+ (cb_line_change): Likewise for local "map".
+
2015-05-19 Mikhail Maltsev <maltsevm@gmail.com>
* interface.c (compare_actual_formal): Use std::swap instead of
/* Callback routines for the parser. Most of these are active only
in specific modes. */
-static void cb_file_change (cpp_reader *, const struct line_map *);
+static void cb_file_change (cpp_reader *, const line_map_ordinary *);
static void cb_line_change (cpp_reader *, const cpp_token *, int);
static void cb_define (cpp_reader *, source_location, cpp_hashnode *);
static void cb_undef (cpp_reader *, source_location, cpp_hashnode *);
static void
maybe_print_line (source_location src_loc)
{
- const struct line_map *map = linemap_lookup (line_table, src_loc);
+ const line_map_ordinary *map
+ = linemap_check_ordinary (linemap_lookup (line_table, src_loc));
int src_line = SOURCE_LINE (map, src_loc);
/* End the previous line of text. */
}
static void
-cb_file_change (cpp_reader * ARG_UNUSED (pfile), const struct line_map *map)
+cb_file_change (cpp_reader * ARG_UNUSED (pfile), const line_map_ordinary *map)
{
const char *flags = "";
/* Bring current file to correct line when entering a new file. */
if (map->reason == LC_ENTER)
{
- const struct line_map *from = INCLUDED_FROM (line_table, map);
+ const line_map_ordinary *from = INCLUDED_FROM (line_table, map);
maybe_print_line (LAST_SOURCE_LINE_LOCATION (from));
}
if (map->reason == LC_ENTER)
ought to care. Some things do care; the fault lies with them. */
if (!CPP_OPTION (pfile, traditional))
{
- const struct line_map *map = linemap_lookup (line_table, src_loc);
+ const line_map_ordinary *map
+ = linemap_check_ordinary (linemap_lookup (line_table, src_loc));
int spaces = SOURCE_COLUMN (map, src_loc) - 2;
print.printed = 1;
error_cb (cpp_reader *, int errtype, int, source_location location,
unsigned int, const char *msg, va_list *ap)
{
- const line_map *map;
+ const line_map_ordinary *map;
linemap_resolve_location (line_table, location, LRK_SPELLING_LOCATION, &map);
expanded_location loc = linemap_expand_location (line_table, map, location);
fprintf (stderr, "%s:%d:%d %s: ", loc.file, loc.line, loc.column,
output_line_directive (FILE *f, source_location location,
bool dumpfile = false)
{
- const line_map *map;
+ const line_map_ordinary *map;
linemap_resolve_location (line_table, location, LRK_SPELLING_LOCATION, &map);
expanded_location loc = linemap_expand_location (line_table, map, location);
if (dumpfile)
bool expansion_point_p)
{
expanded_location xloc;
- const struct line_map *map;
+ const line_map_ordinary *map;
enum location_resolution_kind lrk = LRK_MACRO_EXPANSION_POINT;
tree block = NULL;
location (toward the expansion point) that is not reserved;
that is, the first location that is in real source code. */
loc = linemap_unwind_to_first_non_reserved_loc (line_table,
- loc, &map);
+ loc, NULL);
lrk = LRK_SPELLING_LOCATION;
}
loc = linemap_resolve_location (line_table, loc,
bool
is_location_from_builtin_token (source_location loc)
{
- const line_map *map = NULL;
+ const line_map_ordinary *map = NULL;
loc = linemap_resolve_location (line_table, loc,
LRK_SPELLING_LOCATION, &map);
return loc == BUILTINS_LOCATION;
source_location end_location = get_end_location (line_table, idx);
/* half-closed: doesn't include this one. */
- struct line_map *map = LINEMAPS_ORDINARY_MAP_AT (line_table, idx);
+ const line_map_ordinary *map
+ = LINEMAPS_ORDINARY_MAP_AT (line_table, idx);
fprintf (stream, "ORDINARY MAP: %i\n", idx);
dump_location_range (stream,
MAP_START_LOCATION (map), end_location);
unsigned int idx = (ascending_source_locations
? (LINEMAPS_MACRO_USED (line_table) - (i + 1))
: i);
- struct line_map *map = LINEMAPS_MACRO_MAP_AT (line_table, idx);
+ const line_map_macro *map = LINEMAPS_MACRO_MAP_AT (line_table, idx);
fprintf (stream, "MACRO %i: %s (%u tokens)\n",
idx,
linemap_map_get_macro_name (map),
below. */
typedef struct
{
- const struct line_map *map;
+ const line_map_macro *map;
source_location where;
} loc_map_pair;
do
{
loc.where = where;
- loc.map = map;
+ loc.map = linemap_check_macro (map);
loc_vec.safe_push (loc);
/* Now map is set to the map of the location in the source that
first triggered the macro expansion. This must be an ordinary map. */
+ const line_map_ordinary *ord_map = linemap_check_ordinary (map);
/* Walk LOC_VEC and print the macro expansion trace, unless the
first macro which expansion triggered this trace was expanded
int saved_location_line =
expand_location_to_spelling_point (diagnostic_location (diagnostic)).line;
- if (!LINEMAP_SYSP (map))
+ if (!LINEMAP_SYSP (ord_map))
FOR_EACH_VEC_ELT (loc_vec, ix, iter)
{
/* Sometimes, in the unwound macro expansion trace, we want to
/* Don't print trace for locations that are reserved or from
within a system header. */
- const struct line_map *m = NULL;
+ const line_map_ordinary *m = NULL;
source_location l =
linemap_resolve_location (line_table, resolved_def_loc,
LRK_SPELLING_LOCATION, &m);
+2015-05-19 David Malcolm <dmalcolm@redhat.com>
+
+ * directives.c (do_line): Strengthen local "map" from
+ const line_map * to const line_map_ordinary *.
+ (do_linemarker): Likewise.
+ (_cpp_do_file_change): Assert that we're not dealing with
+ a macro map. Introduce local "ord_map" via a call to
+ linemap_check_ordinary, guarded within the check for
+ non-NULL. Use it for typesafety.
+ * files.c (cpp_make_system_header): Strengthen local "map" from
+ const line_map * to const line_map_ordinary *.
+ * include/cpplib.h (struct cpp_callbacks): Likewise for second
+ parameter of "file_change" callback.
+ * include/line-map.h (struct line_map): Convert from a struct
+ containing a union to a base class.
+ (struct line_map_ordinary): Convert to a subclass of line_map.
+ (struct line_map_macro): Likewise.
+ (linemap_check_ordinary): Strengthen return type from line_map *
+ to line_map_ordinary *, and add a const-variant.
+ (linemap_check_macro): New pair of functions.
+ (ORDINARY_MAP_STARTING_LINE_NUMBER): Strengthen param from
+ const line_map * to const line_map_ordinary *, eliminating call
+ to linemap_check_ordinary. Likewise for the non-const variant.
+ (ORDINARY_MAP_INCLUDER_FILE_INDEX): Likewise.
+ (ORDINARY_MAP_IN_SYSTEM_HEADER_P): Likewise.
+ (ORDINARY_MAP_NUMBER_OF_COLUMN_BITS): Likewise.
+ (ORDINARY_MAP_FILE_NAME): Likewise.
+ (MACRO_MAP_MACRO): Strengthen param from const line_map * to
+ const line_map_macro *. Likewise for the non-const variant.
+ (MACRO_MAP_NUM_MACRO_TOKENS): Likewise.
+ (MACRO_MAP_LOCATIONS): Likewise.
+ (MACRO_MAP_EXPANSION_POINT_LOCATION): Likewise.
+ (struct maps_info): Replace with...
+ (struct maps_info_ordinary):...this and...
+ (struct maps_info_macro): ...this.
+ (struct line_maps): Convert fields "info_ordinary" and
+ "info_macro" to the above new structs.
+ (LINEMAPS_MAP_INFO): Delete both functions.
+ (LINEMAPS_MAPS): Likewise.
+ (LINEMAPS_ALLOCATED): Rewrite both variants to avoid using
+ LINEMAPS_MAP_INFO.
+ (LINEMAPS_USED): Likewise.
+ (LINEMAPS_CACHE): Likewise.
+ (LINEMAPS_MAP_AT): Likewise.
+ (LINEMAPS_ORDINARY_MAPS): Strengthen return type from line_map *
+ to line_map_ordinary *.
+ (LINEMAPS_ORDINARY_MAP_AT): Likewise.
+ (LINEMAPS_LAST_ORDINARY_MAP): Likewise.
+ (LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP): Likewise.
+ (LINEMAPS_MACRO_MAPS): Strengthen return type from line_map * to
+ line_map_macro *.
+ (LINEMAPS_MACRO_MAP_AT): Likewise.
+ (LINEMAPS_LAST_MACRO_MAP): Likewise.
+ (LINEMAPS_LAST_ALLOCATED_MACRO_MAP): Likewise.
+ (linemap_map_get_macro_name): Strengthen param from
+ const line_map * to const line_map_macro *.
+ (SOURCE_LINE): Strengthen first param from const line_map * to
+ const line_map_ordinary *, removing call to
+ linemap_check_ordinary.
+ (SOURCE_COLUMN): Likewise.
+ (LAST_SOURCE_LINE_LOCATION): Likewise.
+ (LAST_SOURCE_LINE): Strengthen first param from const line_map *
+ to const line_map_ordinary *.
+ (LAST_SOURCE_COLUMN): Likewise.
+ (INCLUDED_FROM): Strengthen return type from line_map * to
+ line_map_ordinary *., and second param from const line_map *
+ to const line_map_ordinary *, removing call to
+ linemap_check_ordinary.
+ (MAIN_FILE_P): Strengthen param from const line_map * to
+ const line_map_ordinary *, removing call to
+ linemap_check_ordinary.
+ (linemap_position_for_line_and_column): Strengthen param from
+ const line_map * to const line_map_ordinary *.
+ (LINEMAP_FILE): Strengthen param from const line_map * to
+ const line_map_ordinary *, removing call to
+ linemap_check_ordinary.
+ (LINEMAP_LINE): Likewise.
+ (LINEMAP_SYSP): Likewise.
+ (linemap_resolve_location): Strengthen final param from
+ const line_map ** to const line_map_ordinary **.
+ * internal.h (CPP_INCREMENT_LINE): Likewise for local "map".
+ (linemap_enter_macro): Strengthen return type from
+ const line_map * to const line_map_macro *.
+ (linemap_add_macro_token): Likewise for first param.
+ * line-map.c (linemap_check_files_exited): Strengthen local "map"
+ from const line_map * to const line_map_ordinary *.
+ (new_linemap): Introduce local "map_size" and use it when
+ calculating how large the buffer should be. Rewrite based
+ on change of info_macro and info_ordinary into distinct types.
+ (linemap_add): Strengthen locals "map" and "from" from line_map *
+ to line_map_ordinary *.
+ (linemap_enter_macro): Strengthen return type from
+ const line_map * to const line_map_macro *, and local "map" from
+ line_map * to line_map_macro *.
+ (linemap_add_macro_token): Strengthen param "map" from
+ const line_map * to const line_map_macro *.
+ (linemap_line_start): Strengthen local "map" from line_map * to
+ line_map_ordinary *.
+ (linemap_position_for_column): Likewise.
+ (linemap_position_for_line_and_column): Strengthen first param
+ from const line_map * to const line_map_ordinary *.
+ (linemap_position_for_loc_and_offset): Strengthen local "map" from
+ const line_map * to const line_map_ordinary *.
+ (linemap_ordinary_map_lookup): Likewise for return type and locals
+ "cached" and "result".
+ (linemap_macro_map_lookup): Strengthen return type and locals
+ "cached" and "result" from const line_map * to
+ const line_map_macro *.
+ (linemap_macro_map_loc_to_exp_point): Likewise for param "map".
+ (linemap_macro_map_loc_to_def_point): Likewise.
+ (linemap_macro_map_loc_unwind_toward_spelling): Likewise.
+ (linemap_get_expansion_line): Strengthen local "map" from
+ const line_map * to const line_map_ordinary *.
+ (linemap_get_expansion_filename): Likewise.
+ (linemap_map_get_macro_name): Strengthen param from
+ const line_map * to const line_map_macro *.
+ (linemap_location_in_system_header_p): Add call to
+ linemap_check_ordinary in region guarded by
+ !linemap_macro_expansion_map_p. Introduce local "macro_map" via
+ linemap_check_macro in other region, using it in place of "map"
+ for typesafety.
+ (first_map_in_common_1): Add calls to linemap_check_macro.
+ (trace_include): Strengthen param "map" from const line_map * to
+ const line_map_ordinary *.
+ (linemap_macro_loc_to_spelling_point): Strengthen final param from
+ const line_map ** to const line_map_ordinary **. Replace a
+ C-style cast with a const_cast, and add calls to
+ linemap_check_macro and linemap_check_ordinary.
+ (linemap_macro_loc_to_def_point): Likewise.
+ (linemap_macro_loc_to_exp_point): Likewise.
+ (linemap_resolve_location): Strengthen final param from
+ const line_map ** to const line_map_ordinary **.
+ (linemap_unwind_toward_expansion): Introduce local "macro_map" via
+ a checked cast and use it in place of *map.
+ (linemap_unwind_to_first_non_reserved_loc): Strengthen local
+ "map1" from const line_map * to const line_map_ordinary *.
+ (linemap_expand_location): Introduce local "ord_map" via a checked
+ cast and use it in place of map.
+ (linemap_dump): Make local "map" const. Strengthen local
+ "includer_map" from line_map * to const line_map_ordinary *.
+ Introduce locals "ord_map" and "macro_map" via checked casts and
+ use them in place of "map" for typesafety.
+ (linemap_dump_location): Strengthen local "map" from
+ const line_map * to const line_map_ordinary *.
+ (linemap_get_file_highest_location): Update for elimination of
+ union.
+ (linemap_get_statistics): Strengthen local "cur_map" from
+ line_map * to const line_map_macro *. Update uses of sizeof to
+ use the appropriate line_map subclasses.
+ * macro.c (_cpp_warn_if_unused_macro): Add call to
+ linemap_check_ordinary.
+ (builtin_macro): Strengthen local "map" from const line_map * to
+ const line_map_macro *.
+ (enter_macro_context): Likewise.
+ (replace_args): Likewise.
+ (tokens_buff_put_token_to): Likewise for param "map".
+ (tokens_buff_add_token): Likewise.
+
2015-05-13 David Malcolm <dmalcolm@redhat.com>
* include/line-map.h (source_location): Add a reference to
do_line (cpp_reader *pfile)
{
struct line_maps *line_table = pfile->line_table;
- const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
+ const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
/* skip_rest_of_line() may cause line table to be realloc()ed so note down
sysp right now. */
do_linemarker (cpp_reader *pfile)
{
struct line_maps *line_table = pfile->line_table;
- const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
+ const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
const cpp_token *token;
const char *new_file = ORDINARY_MAP_FILE_NAME (map);
linenum_type new_lineno;
const char *to_file, linenum_type file_line,
unsigned int sysp)
{
+ linemap_assert (reason != LC_ENTER_MACRO);
const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
to_file, file_line);
+ const line_map_ordinary *ord_map = NULL;
if (map != NULL)
- linemap_line_start (pfile->line_table,
- ORDINARY_MAP_STARTING_LINE_NUMBER (map),
- 127);
+ {
+ ord_map = linemap_check_ordinary (map);
+ linemap_line_start (pfile->line_table,
+ ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map),
+ 127);
+ }
if (pfile->cb.file_change)
- pfile->cb.file_change (pfile, map);
+ pfile->cb.file_change (pfile, ord_map);
}
/* Report a warning or error detected by the program we are
{
int flags = 0;
const struct line_maps *line_table = pfile->line_table;
- const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
+ const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
/* 1 = system header, 2 = system header to be treated as C. */
if (syshdr)
flags = 1 + (externc != 0);
The line_map is for the new file. It is NULL if there is no new file.
(In C this happens when done with <built-in>+<command line> and also
when done with a main file.) This can be used for resource cleanup. */
- void (*file_change) (cpp_reader *, const struct line_map *);
+ void (*file_change) (cpp_reader *, const line_map_ordinary *);
void (*dir_change) (cpp_reader *, const char *);
void (*include) (cpp_reader *, source_location, const unsigned char *,
for a given requested allocation. */
typedef size_t (*line_map_round_alloc_size_func) (size_t);
+/* A line_map encodes a sequence of locations.
+ There are two kinds of maps. Ordinary maps and macro expansion
+ maps, a.k.a macro maps.
+
+ A macro map encodes source locations of tokens that are part of a
+ macro replacement-list, at a macro expansion point. E.g, in:
+
+ #define PLUS(A,B) A + B
+
+ No macro map is going to be created there, because we are not at a
+ macro expansion point. We are at a macro /definition/ point. So the
+ locations of the tokens of the macro replacement-list (i.e, A + B)
+ will be locations in an ordinary map, not a macro map.
+
+ On the other hand, if we later do:
+
+ int a = PLUS (1,2);
+
+ The invocation of PLUS here is a macro expansion. So we are at a
+ macro expansion point. The preprocessor expands PLUS (1,2) and
+ replaces it with the tokens of its replacement-list: 1 + 2. A macro
+ map is going to be created to hold (or rather to map, haha ...) the
+ locations of the tokens 1, + and 2. The macro map also records the
+ location of the expansion point of PLUS. That location is mapped in
+ the map that is active right before the location of the invocation
+ of PLUS. */
+struct GTY((tag ("0"), desc ("%h.reason == LC_ENTER_MACRO ? 2 : 1"))) line_map {
+ source_location start_location;
+
+ /* The reason for creation of this line map. */
+ ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
+};
+
/* An ordinary line map encodes physical source locations. Those
physical source locations are called "spelling locations".
means "entire file/line" or "unknown line/column" or "not applicable".)
The highest possible source location is MAX_SOURCE_LOCATION. */
-struct GTY(()) line_map_ordinary {
+struct GTY((tag ("1"))) line_map_ordinary : public line_map {
const char *to_file;
linenum_type to_line;
/* A macro line map encodes location of tokens coming from a macro
expansion.
- Please note that this struct line_map_macro is a field of struct
- line_map below, go read the comments of struct line_map below and
- then come back here.
-
The offset from START_LOCATION is used to index into
MACRO_LOCATIONS; this holds the original location of the token. */
-struct GTY(()) line_map_macro {
+struct GTY((tag ("2"))) line_map_macro : public line_map {
/* The cpp macro which expansion gave birth to this macro map. */
struct cpp_hashnode * GTY ((nested_ptr (union tree_node,
"%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
source_location expansion;
};
-/* A line_map encodes a sequence of locations.
- There are two kinds of maps. Ordinary maps and macro expansion
- maps, a.k.a macro maps.
-
- A macro map encodes source locations of tokens that are part of a
- macro replacement-list, at a macro expansion point. E.g, in:
-
- #define PLUS(A,B) A + B
-
- No macro map is going to be created there, because we are not at a
- macro expansion point. We are at a macro /definition/ point. So the
- locations of the tokens of the macro replacement-list (i.e, A + B)
- will be locations in an ordinary map, not a macro map.
-
- On the other hand, if we later do:
-
- int a = PLUS (1,2);
-
- The invocation of PLUS here is a macro expansion. So we are at a
- macro expansion point. The preprocessor expands PLUS (1,2) and
- replaces it with the tokens of its replacement-list: 1 + 2. A macro
- map is going to be created to hold (or rather to map, haha ...) the
- locations of the tokens 1, + and 2. The macro map also records the
- location of the expansion point of PLUS. That location is mapped in
- the map that is active right before the location of the invocation
- of PLUS. */
-struct GTY(()) line_map {
- source_location start_location;
-
- /* The reason for creation of this line map. */
- ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
-
- union map_u {
- struct line_map_ordinary GTY((tag ("0"))) ordinary;
- struct line_map_macro GTY((tag ("1"))) macro;
- } GTY((desc ("%1.reason == LC_ENTER_MACRO"))) d;
-};
-
#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
/* Assertion macro to be used in line-map code. */
linemap_macro_expansion_map_p (const struct line_map *);
/* Assert that MAP encodes locations of tokens that are not part of
- the replacement-list of a macro expansion. */
-inline struct line_map *
+ the replacement-list of a macro expansion, downcasting from
+ line_map * to line_map_ordinary *. */
+
+inline line_map_ordinary *
linemap_check_ordinary (struct line_map *map)
{
linemap_assert (!linemap_macro_expansion_map_p (map));
- return map;
+ return (line_map_ordinary *)map;
}
/* Assert that MAP encodes locations of tokens that are not part of
- the replacement-list of a macro expansion. */
+ the replacement-list of a macro expansion, downcasting from
+ const line_map * to const line_map_ordinary *. */
-inline const struct line_map *
+inline const line_map_ordinary *
linemap_check_ordinary (const struct line_map *map)
{
linemap_assert (!linemap_macro_expansion_map_p (map));
- return map;
+ return (const line_map_ordinary *)map;
+}
+
+/* Assert that MAP is a macro expansion and downcast to the appropriate
+ subclass. */
+
+inline line_map_macro *linemap_check_macro (line_map *map)
+{
+ linemap_assert (linemap_macro_expansion_map_p (map));
+ return (line_map_macro *)map;
+}
+
+/* Assert that MAP is a macro expansion and downcast to the appropriate
+ subclass. */
+
+inline const line_map_macro *
+linemap_check_macro (const line_map *map)
+{
+ linemap_assert (linemap_macro_expansion_map_p (map));
+ return (const line_map_macro *)map;
}
/* Read the start location of MAP, as an rvalue. */
/* Get the starting line number of ordinary map MAP. */
inline linenum_type
-ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map *map)
+ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.to_line;
+ return ord_map->to_line;
}
/* Access the starting line number of ordinary map MAP by
reference (e.g. as an lvalue). */
inline linenum_type&
-ORDINARY_MAP_STARTING_LINE_NUMBER (line_map *map)
+ORDINARY_MAP_STARTING_LINE_NUMBER (line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.to_line;
+ return ord_map->to_line;
}
/* Get the index of the ordinary map at whose end
File(s) at the bottom of the include stack have this set. */
inline int
-ORDINARY_MAP_INCLUDER_FILE_INDEX (const line_map *map)
+ORDINARY_MAP_INCLUDER_FILE_INDEX (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.included_from;
+ return ord_map->included_from;
}
/* As above, but by reference (e.g. as an lvalue). */
inline int&
-ORDINARY_MAP_INCLUDER_FILE_INDEX (line_map *map)
+ORDINARY_MAP_INCLUDER_FILE_INDEX (line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.included_from;
+ return ord_map->included_from;
}
/* Return a positive value if map encodes locations from a system
that therefore needs to be extern "C" protected in C++. */
inline unsigned char
-ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map *map)
+ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.sysp;
+ return ord_map->sysp;
}
/* As above, but by reference (e.g. as an lvalue). */
inline unsigned char &
-ORDINARY_MAP_IN_SYSTEM_HEADER_P (line_map *map)
+ORDINARY_MAP_IN_SYSTEM_HEADER_P (line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.sysp;
+ return ord_map->sysp;
}
/* Get the number of the low-order source_location bits used for a
column number within ordinary map MAP. */
inline unsigned char
-ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (const line_map *map)
+ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.column_bits;
+ return ord_map->column_bits;
}
/* Set the number of the low-order source_location bits used for a
column number within ordinary map MAP. */
inline void
-SET_ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (line_map *map, int col_bits)
+SET_ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (line_map_ordinary *ord_map,
+ int col_bits)
{
- linemap_check_ordinary (map)->d.ordinary.column_bits = col_bits;
+ ord_map->column_bits = col_bits;
}
/* Get the filename of ordinary map MAP. */
inline const char *
-ORDINARY_MAP_FILE_NAME (const line_map *map)
+ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.to_file;
+ return ord_map->to_file;
}
/* As above, but by reference (e.g. as an lvalue). */
inline const char * &
-ORDINARY_MAP_FILE_NAME (line_map *map)
+ORDINARY_MAP_FILE_NAME (line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.to_file;
+ return ord_map->to_file;
}
/* Get the cpp macro whose expansion gave birth to macro map MAP. */
inline cpp_hashnode *
-MACRO_MAP_MACRO (const line_map *map)
+MACRO_MAP_MACRO (const line_map_macro *macro_map)
{
- return map->d.macro.macro;
+ return macro_map->macro;
}
/* As above, but by reference (e.g. as an lvalue). */
inline cpp_hashnode * &
-MACRO_MAP_MACRO (line_map *map)
+MACRO_MAP_MACRO (line_map_macro *macro_map)
{
- return map->d.macro.macro;
+ return macro_map->macro;
}
/* Get the number of tokens inside the replacement-list of the macro
that led to macro map MAP. */
inline unsigned int
-MACRO_MAP_NUM_MACRO_TOKENS (const line_map *map)
+MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map)
{
- return map->d.macro.n_tokens;
+ return macro_map->n_tokens;
}
/* As above, but by reference (e.g. as an lvalue). */
inline unsigned int &
-MACRO_MAP_NUM_MACRO_TOKENS (line_map *map)
+MACRO_MAP_NUM_MACRO_TOKENS (line_map_macro *macro_map)
{
- return map->d.macro.n_tokens;
+ return macro_map->n_tokens;
}
/* Get the array of pairs of locations within macro map MAP.
See the declaration of line_map_macro for more information. */
inline source_location *
-MACRO_MAP_LOCATIONS (const line_map *map)
+MACRO_MAP_LOCATIONS (const line_map_macro *macro_map)
{
- return map->d.macro.macro_locations;
+ return macro_map->macro_locations;
}
/* As above, but by reference (e.g. as an lvalue). */
inline source_location * &
-MACRO_MAP_LOCATIONS (line_map *map)
+MACRO_MAP_LOCATIONS (line_map_macro *macro_map)
{
- return map->d.macro.macro_locations;
+ return macro_map->macro_locations;
}
/* Get the location of the expansion point of the macro map MAP. */
inline source_location
-MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map *map)
+MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro *macro_map)
{
- return map->d.macro.expansion;
+ return macro_map->expansion;
}
/* As above, but by reference (e.g. as an lvalue). */
inline source_location &
-MACRO_MAP_EXPANSION_POINT_LOCATION (line_map *map)
+MACRO_MAP_EXPANSION_POINT_LOCATION (line_map_macro *macro_map)
{
- return map->d.macro.expansion;
+ return macro_map->expansion;
}
/* The abstraction of a set of location maps. There can be several
types of location maps. This abstraction contains the attributes
- that are independent from the type of the map. */
-struct GTY(()) maps_info {
- /* This array contains the different line maps.
- A line map is created for the following events:
- - when a new preprocessing unit start.
- - when a preprocessing unit ends.
- - when a macro expansion occurs. */
- struct line_map * GTY ((length ("%h.used"))) maps;
+ that are independent from the type of the map.
+
+ Essentially this is just a vector of T_linemap_subclass,
+ which can only ever grow in size. */
+
+struct GTY(()) maps_info_ordinary {
+ /* This array contains the "ordinary" line maps, for all
+ events other than macro expansion
+ (e.g. when a new preprocessing unit starts or ends). */
+ line_map_ordinary * GTY ((length ("%h.used"))) maps;
+
+ /* The total number of allocated maps. */
+ unsigned int allocated;
+
+ /* The number of elements used in maps. This number is smaller
+ or equal to ALLOCATED. */
+ unsigned int used;
+
+ unsigned int cache;
+};
+
+struct GTY(()) maps_info_macro {
+ /* This array contains the macro line maps.
+ A macro line map is created whenever a macro expansion occurs. */
+ line_map_macro * GTY ((length ("%h.used"))) maps;
/* The total number of allocated maps. */
unsigned int allocated;
/* A set of chronological line_map structures. */
struct GTY(()) line_maps {
- struct maps_info info_ordinary;
+ maps_info_ordinary info_ordinary;
- struct maps_info info_macro;
+ maps_info_macro info_macro;
/* Depth of the include stack, including the current file. */
unsigned int depth;
bool seen_line_directive;
};
-/* Returns the pointer to the memory region where information about
- maps are stored in the line table SET. MACRO_MAP_P is a flag
- telling if we want macro or ordinary maps. */
-inline struct maps_info *
-LINEMAPS_MAP_INFO (line_maps *set, bool macro_map_p)
-{
- return (macro_map_p
- ? &(set->info_macro)
- : &(set->info_ordinary));
-}
-
-/* As above, but preserving constness. */
-
-inline const struct maps_info *
-LINEMAPS_MAP_INFO (const line_maps *set, bool macro_map_p)
-{
- return (macro_map_p
- ? &(set->info_macro)
- : &(set->info_ordinary));
-}
-
-/* Returns the pointer to the memory region where maps are stored in
- the line table SET. MAP_KIND shall be TRUE if we are interested in
- macro maps false otherwise. */
-inline line_map *
-LINEMAPS_MAPS (const line_maps *set, bool map_kind)
-{
- return LINEMAPS_MAP_INFO (set, map_kind)->maps;
-}
-
-/* As above, but by reference (e.g. as an lvalue). */
-
-inline line_map * &
-LINEMAPS_MAPS (line_maps *set, bool map_kind)
-{
- return LINEMAPS_MAP_INFO (set, map_kind)->maps;
-}
-
/* Returns the number of allocated maps so far. MAP_KIND shall be TRUE
if we are interested in macro maps, FALSE otherwise. */
inline unsigned int
LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind)
{
- return LINEMAPS_MAP_INFO (set, map_kind)->allocated;
+ if (map_kind)
+ return set->info_macro.allocated;
+ else
+ return set->info_ordinary.allocated;
}
/* As above, but by reference (e.g. as an lvalue). */
inline unsigned int &
LINEMAPS_ALLOCATED (line_maps *set, bool map_kind)
{
- return LINEMAPS_MAP_INFO (set, map_kind)->allocated;
+ if (map_kind)
+ return set->info_macro.allocated;
+ else
+ return set->info_ordinary.allocated;
}
/* Returns the number of used maps so far. MAP_KIND shall be TRUE if
inline unsigned int
LINEMAPS_USED (const line_maps *set, bool map_kind)
{
- return LINEMAPS_MAP_INFO (set, map_kind)->used;
+ if (map_kind)
+ return set->info_macro.used;
+ else
+ return set->info_ordinary.used;
}
/* As above, but by reference (e.g. as an lvalue). */
inline unsigned int &
LINEMAPS_USED (line_maps *set, bool map_kind)
{
- return LINEMAPS_MAP_INFO (set, map_kind)->used;
+ if (map_kind)
+ return set->info_macro.used;
+ else
+ return set->info_ordinary.used;
}
/* Returns the index of the last map that was looked up with
inline unsigned int
LINEMAPS_CACHE (const line_maps *set, bool map_kind)
{
- return LINEMAPS_MAP_INFO (set, map_kind)->cache;
+ if (map_kind)
+ return set->info_macro.cache;
+ else
+ return set->info_ordinary.cache;
}
/* As above, but by reference (e.g. as an lvalue). */
inline unsigned int &
LINEMAPS_CACHE (line_maps *set, bool map_kind)
{
- return LINEMAPS_MAP_INFO (set, map_kind)->cache;
+ if (map_kind)
+ return set->info_macro.cache;
+ else
+ return set->info_ordinary.cache;
}
/* Return the map at a given index. */
inline line_map *
LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int index)
{
- return &(LINEMAPS_MAPS (set, map_kind)[index]);
+ if (map_kind)
+ return &set->info_macro.maps[index];
+ else
+ return &set->info_ordinary.maps[index];
}
/* Returns the last map used in the line table SET. MAP_KIND
/* Returns a pointer to the memory region where ordinary maps are
allocated in the line table SET. */
-inline line_map *
+inline line_map_ordinary *
LINEMAPS_ORDINARY_MAPS (const line_maps *set)
{
- return LINEMAPS_MAPS (set, false);
+ return set->info_ordinary.maps;
}
/* Returns the INDEXth ordinary map. */
-inline line_map *
+inline line_map_ordinary *
LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index)
{
- return LINEMAPS_MAP_AT (set, false, index);
+ linemap_assert (index >= 0);
+ linemap_assert ((unsigned int)index < set->info_ordinary.used);
+ return &set->info_ordinary.maps[index];
}
/* Return the number of ordinary maps allocated in the line table
/* Returns a pointer to the last ordinary map used in the line table
SET. */
-inline line_map *
+inline line_map_ordinary *
LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set)
{
- return LINEMAPS_LAST_MAP (set, false);
+ return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, false);
}
/* Returns a pointer to the last ordinary map allocated the line table
SET. */
-inline line_map *
+inline line_map_ordinary *
LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps *set)
{
- return LINEMAPS_LAST_ALLOCATED_MAP (set, false);
+ return (line_map_ordinary *)LINEMAPS_LAST_ALLOCATED_MAP (set, false);
}
/* Returns a pointer to the beginning of the region where macro maps
are allcoated. */
-inline line_map *
+inline line_map_macro *
LINEMAPS_MACRO_MAPS (const line_maps *set)
{
- return LINEMAPS_MAPS (set, true);
+ return set->info_macro.maps;
}
/* Returns the INDEXth macro map. */
-inline line_map *
+inline line_map_macro *
LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index)
{
- return LINEMAPS_MAP_AT (set, true, index);
+ linemap_assert (index >= 0);
+ linemap_assert ((unsigned int)index < set->info_macro.used);
+ return &set->info_macro.maps[index];
}
/* Returns the number of macro maps that were allocated in the line
}
/* Returns the last macro map used in the line table SET. */
-inline line_map *
+inline line_map_macro *
LINEMAPS_LAST_MACRO_MAP (const line_maps *set)
{
- return LINEMAPS_LAST_MAP (set, true);
+ return (line_map_macro *)LINEMAPS_LAST_MAP (set, true);
}
/* Returns the lowest location [of a token resulting from macro
}
/* Returns the last macro map allocated in the line table SET. */
-inline line_map *
+inline line_map_macro *
LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set)
{
- return LINEMAPS_LAST_ALLOCATED_MAP (set, true);
+ return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true);
}
extern void location_adhoc_data_fini (struct line_maps *);
bool linemap_tracks_macro_expansion_locs_p (struct line_maps *);
/* Return the name of the macro associated to MACRO_MAP. */
-const char* linemap_map_get_macro_name (const struct line_map*);
+const char* linemap_map_get_macro_name (const line_map_macro *);
/* Return a positive value if LOCATION is the locus of a token that is
located in a system header, O otherwise. It returns 1 if LOCATION
/* Converts a map and a source_location to source line. */
inline linenum_type
-SOURCE_LINE (const struct line_map *map, source_location loc)
+SOURCE_LINE (const line_map_ordinary *ord_map, source_location loc)
{
- return ((loc - linemap_check_ordinary (map)->start_location)
- >> map->d.ordinary.column_bits) + map->d.ordinary.to_line;
+ return ((loc - ord_map->start_location)
+ >> ord_map->column_bits) + ord_map->to_line;
}
/* Convert a map and source_location to source column number. */
inline linenum_type
-SOURCE_COLUMN (const struct line_map *map, source_location loc)
+SOURCE_COLUMN (const line_map_ordinary *ord_map, source_location loc)
{
- return ((loc - linemap_check_ordinary (map)->start_location)
- & ((1 << map->d.ordinary.column_bits) - 1));
+ return ((loc - ord_map->start_location)
+ & ((1 << ord_map->column_bits) - 1));
}
/* Return the location of the last source line within an ordinary
map. */
inline source_location
-LAST_SOURCE_LINE_LOCATION (const struct line_map *map)
+LAST_SOURCE_LINE_LOCATION (const line_map_ordinary *map)
{
- return (((linemap_check_ordinary (map)[1].start_location - 1
+ return (((map[1].start_location - 1
- map->start_location)
- & ~((1 << map->d.ordinary.column_bits) - 1))
+ & ~((1 << map->column_bits) - 1))
+ map->start_location);
}
/* Returns the last source line number within an ordinary map. This
is the (last) line of the #include, or other directive, that caused
a map change. */
-
inline linenum_type
-LAST_SOURCE_LINE (const struct line_map *map)
+LAST_SOURCE_LINE (const line_map_ordinary *map)
{
return SOURCE_LINE (map, LAST_SOURCE_LINE_LOCATION (map));
}
/* Return the last column number within an ordinary map. */
inline linenum_type
-LAST_SOURCE_COLUMN (const struct line_map *map)
+LAST_SOURCE_COLUMN (const line_map_ordinary *map)
{
return SOURCE_COLUMN (map, LAST_SOURCE_LINE_LOCATION (map));
}
/* Returns the map a given map was included from, or NULL if the map
belongs to the main file, i.e, a file that wasn't included by
another one. */
-
-inline struct line_map *
-INCLUDED_FROM (struct line_maps *set, const struct line_map *map)
+inline line_map_ordinary *
+INCLUDED_FROM (struct line_maps *set, const line_map_ordinary *ord_map)
{
- return ((linemap_check_ordinary (map)->d.ordinary.included_from == -1)
+ return ((ord_map->included_from == -1)
? NULL
- : (&LINEMAPS_ORDINARY_MAPS (set)[(map)->d.ordinary.included_from]));
+ : LINEMAPS_ORDINARY_MAP_AT (set, ord_map->included_from));
}
/* True if the map is at the bottom of the include stack. */
inline bool
-MAIN_FILE_P (const struct line_map *map)
+MAIN_FILE_P (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.included_from < 0;
+ return ord_map->included_from < 0;
}
/* Encode and return a source_location from a column number. The
/* Encode and return a source location from a given line and
column. */
source_location
-linemap_position_for_line_and_column (const struct line_map *,
+linemap_position_for_line_and_column (const line_map_ordinary *,
linenum_type, unsigned int);
/* Encode and return a source_location starting from location LOC and
/* Return the file this map is for. */
inline const char *
-LINEMAP_FILE (const struct line_map *map)
+LINEMAP_FILE (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.to_file;
+ return ord_map->to_file;
}
/* Return the line number this map started encoding location from. */
inline linenum_type
-LINEMAP_LINE (const struct line_map *map)
+LINEMAP_LINE (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.to_line;
+ return ord_map->to_line;
}
/* Return a positive value if map encodes locations from a system
system header and 2 if it encodes locations in a C system header
that therefore needs to be extern "C" protected in C++. */
inline unsigned char
-LINEMAP_SYSP (const struct line_map *map)
+LINEMAP_SYSP (const line_map_ordinary *ord_map)
{
- return linemap_check_ordinary (map)->d.ordinary.sysp;
+ return ord_map->sysp;
}
/* Return a positive value if PRE denotes the location of a token that
source_location linemap_resolve_location (struct line_maps *,
source_location loc,
enum location_resolution_kind lrk,
- const struct line_map **loc_map);
+ const line_map_ordinary **loc_map);
/* Suppose that LOC is the virtual location of a token coming from the
expansion of a macro M. This function then steps up to get the
#define CPP_INCREMENT_LINE(PFILE, COLS_HINT) do { \
const struct line_maps *line_table = PFILE->line_table; \
- const struct line_map *map = \
+ const struct line_map_ordinary *map = \
LINEMAPS_LAST_ORDINARY_MAP (line_table); \
linenum_type line = SOURCE_LINE (map, line_table->highest_line); \
linemap_line_start (PFILE->line_table, line + 1, COLS_HINT); \
of the macro, rather than the the location of the first character
of the macro. NUM_TOKENS is the number of tokens that are part of
the replacement-list of MACRO. */
-const struct line_map *linemap_enter_macro (struct line_maps *,
- struct cpp_hashnode*,
- source_location,
- unsigned int);
+const line_map_macro *linemap_enter_macro (struct line_maps *,
+ struct cpp_hashnode*,
+ source_location,
+ unsigned int);
/* Create and return a virtual location for a token that is part of a
macro expansion-list at a macro expansion point. See the comment
MACRO_DEFINITION_LOC is the location in the macro definition,
either of the token itself or of a macro parameter that it
replaces. */
-source_location linemap_add_macro_token (const struct line_map *,
+source_location linemap_add_macro_token (const line_map_macro *,
unsigned int,
source_location,
source_location);
#include "internal.h"
#include "hashtab.h"
-static void trace_include (const struct line_maps *, const struct line_map *);
-static const struct line_map * linemap_ordinary_map_lookup (struct line_maps *,
- source_location);
-static const struct line_map* linemap_macro_map_lookup (struct line_maps *,
- source_location);
+static void trace_include (const struct line_maps *, const line_map_ordinary *);
+static const line_map_ordinary * linemap_ordinary_map_lookup (struct line_maps *,
+ source_location);
+static const line_map_macro* linemap_macro_map_lookup (struct line_maps *,
+ source_location);
static source_location linemap_macro_map_loc_to_def_point
-(const struct line_map*, source_location);
+(const line_map_macro *, source_location);
static source_location linemap_macro_map_loc_unwind_toward_spelling
-(const struct line_map*, source_location);
+(const line_map_macro *, source_location);
static source_location linemap_macro_map_loc_to_exp_point
-(const struct line_map*, source_location);
+(const line_map_macro *, source_location);
static source_location linemap_macro_loc_to_spelling_point
-(struct line_maps *, source_location, const struct line_map **);
+(struct line_maps *, source_location, const line_map_ordinary **);
static source_location linemap_macro_loc_to_def_point (struct line_maps *,
source_location,
- const struct line_map **);
+ const line_map_ordinary **);
static source_location linemap_macro_loc_to_exp_point (struct line_maps *,
source_location,
- const struct line_map **);
+ const line_map_ordinary **);
/* Counters defined in macro.c. */
extern unsigned num_expanded_macros_counter;
void
linemap_check_files_exited (struct line_maps *set)
{
- const struct line_map *map;
+ const line_map_ordinary *map;
/* Depending upon whether we are handling preprocessed input or
not, this can be a user error or an ICE. */
for (map = LINEMAPS_LAST_ORDINARY_MAP (set);
line_map_round_alloc_size_func round_alloc_size =
set->round_alloc_size;
+ size_t map_size = (macro_map_p
+ ? sizeof (line_map_macro)
+ : sizeof (line_map_ordinary));
+
/* We are going to execute some dance to try to reduce the
overhead of the memory allocator, in case we are using the
ggc-page.c one.
alloc_size =
(2 * LINEMAPS_ALLOCATED (set, macro_map_p) + 256)
- * sizeof (struct line_map);
+ * map_size;
/* Get the actual size of memory that is going to be allocated
by the allocator. */
Let's get back to the number of macro map that amounts
to. */
LINEMAPS_ALLOCATED (set, macro_map_p) =
- alloc_size / (sizeof (struct line_map));
+ alloc_size / map_size;
/* And now let's really do the re-allocation. */
- LINEMAPS_MAPS (set, macro_map_p) =
- (struct line_map *) (*reallocator)
- (LINEMAPS_MAPS (set, macro_map_p),
- (LINEMAPS_ALLOCATED (set, macro_map_p)
- * sizeof (struct line_map)));
-
- result =
- &LINEMAPS_MAPS (set, macro_map_p)[LINEMAPS_USED (set, macro_map_p)];
+ if (macro_map_p)
+ {
+ set->info_macro.maps
+ = (line_map_macro *) (*reallocator) (set->info_macro.maps,
+ (LINEMAPS_ALLOCATED (set, macro_map_p)
+ * map_size));
+ result = &set->info_macro.maps[LINEMAPS_USED (set, macro_map_p)];
+ }
+ else
+ {
+ set->info_ordinary.maps =
+ (line_map_ordinary *) (*reallocator) (set->info_ordinary.maps,
+ (LINEMAPS_ALLOCATED (set, macro_map_p)
+ * map_size));
+ result = &set->info_ordinary.maps[LINEMAPS_USED (set, macro_map_p)];
+ }
memset (result, 0,
((LINEMAPS_ALLOCATED (set, macro_map_p)
- LINEMAPS_USED (set, macro_map_p))
- * sizeof (struct line_map)));
+ * map_size));
}
else
- result =
- &LINEMAPS_MAPS (set, macro_map_p)[LINEMAPS_USED (set, macro_map_p)];
+ {
+ if (macro_map_p)
+ result = &set->info_macro.maps[LINEMAPS_USED (set, macro_map_p)];
+ else
+ result = &set->info_ordinary.maps[LINEMAPS_USED (set, macro_map_p)];
+ }
LINEMAPS_USED (set, macro_map_p)++;
linemap_add (struct line_maps *set, enum lc_reason reason,
unsigned int sysp, const char *to_file, linenum_type to_line)
{
- struct line_map *map;
source_location start_location = set->highest_location + 1;
linemap_assert (!(LINEMAPS_ORDINARY_USED (set)
return NULL;
}
- map = new_linemap (set, reason);
+ linemap_assert (reason != LC_ENTER_MACRO);
+ line_map_ordinary *map = linemap_check_ordinary (new_linemap (set, reason));
if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM)
to_file = "<stdin>";
location inside the "includer" right after the #include
"included", this variable points the map in use right before the
#include "included", inside the same "includer" file. */
- struct line_map *from;
+ line_map_ordinary *from;
bool error;
if (MAIN_FILE_P (map - 1))
}
}
- linemap_assert (reason != LC_ENTER_MACRO);
ORDINARY_MAP_IN_SYSTEM_HEADER_P (map) = sysp;
MAP_START_LOCATION (map) = start_location;
ORDINARY_MAP_FILE_NAME (map) = to_file;
this function cannot encode {line,column} pairs into locations of
macro tokens anymore. */
-const struct line_map *
+const line_map_macro *
linemap_enter_macro (struct line_maps *set, struct cpp_hashnode *macro_node,
source_location expansion, unsigned int num_tokens)
{
- struct line_map *map;
+ line_map_macro *map;
source_location start_location;
/* Cast away extern "C" from the type of xrealloc. */
line_map_realloc reallocator = (set->reallocator
/* We ran out of macro map space. */
return NULL;
- map = new_linemap (set, LC_ENTER_MACRO);
+ map = linemap_check_macro (new_linemap (set, LC_ENTER_MACRO));
MAP_START_LOCATION (map) = start_location;
MACRO_MAP_MACRO (map) = macro_node;
replaces. */
source_location
-linemap_add_macro_token (const struct line_map *map,
+linemap_add_macro_token (const line_map_macro *map,
unsigned int token_no,
source_location orig_loc,
source_location orig_parm_replacement_loc)
linemap_line_start (struct line_maps *set, linenum_type to_line,
unsigned int max_column_hint)
{
- struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
+ line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
source_location highest = set->highest_location;
source_location r;
linenum_type last_line =
if (line_delta < 0
|| last_line != ORDINARY_MAP_STARTING_LINE_NUMBER (map)
|| SOURCE_COLUMN (map, highest) >= (1U << column_bits))
- map = (struct line_map *) linemap_add (set, LC_RENAME,
- ORDINARY_MAP_IN_SYSTEM_HEADER_P
- (map),
- ORDINARY_MAP_FILE_NAME (map),
- to_line);
+ map = linemap_check_ordinary
+ (const_cast <line_map *>
+ (linemap_add (set, LC_RENAME,
+ ORDINARY_MAP_IN_SYSTEM_HEADER_P (map),
+ ORDINARY_MAP_FILE_NAME (map),
+ to_line)));
SET_ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map, column_bits);
r = (MAP_START_LOCATION (map)
+ ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
}
else
{
- struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
+ line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set);
r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
}
}
column. */
source_location
-linemap_position_for_line_and_column (const struct line_map *map,
+linemap_position_for_line_and_column (const line_map_ordinary *ord_map,
linenum_type line,
unsigned column)
{
- linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (map) <= line);
+ linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map) <= line);
- return (MAP_START_LOCATION (map)
- + ((line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
- << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map))
- + (column & ((1 << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map)) - 1)));
+ return (MAP_START_LOCATION (ord_map)
+ + ((line - ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map))
+ << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (ord_map))
+ + (column & ((1 << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (ord_map)) - 1)));
}
/* Encode and return a source_location starting from location LOC and
source_location loc,
unsigned int offset)
{
- const struct line_map * map = NULL;
+ const line_map_ordinary * map = NULL;
/* This function does not support virtual locations yet. */
if (linemap_assert_fails
return loc;
offset += SOURCE_COLUMN (map, loc);
- if (linemap_assert_fails (offset < (1u << map->d.ordinary.column_bits)))
+ if (linemap_assert_fails
+ (offset < (1u << map->column_bits)))
return loc;
source_location r =
monotonic increasing, and so the list is sorted and we can use a
binary search. */
-static const struct line_map *
+static const line_map_ordinary *
linemap_ordinary_map_lookup (struct line_maps *set, source_location line)
{
unsigned int md, mn, mx;
- const struct line_map *cached, *result;
+ const line_map_ordinary *cached, *result;
if (IS_ADHOC_LOC (line))
line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
monotonic decreasing, and so the list is sorted and we can use a
binary search. */
-static const struct line_map*
+static const line_map_macro *
linemap_macro_map_lookup (struct line_maps *set, source_location line)
{
unsigned int md, mn, mx;
- const struct line_map *cached, *result;
+ const struct line_map_macro *cached, *result;
if (IS_ADHOC_LOC (line))
line = set->location_adhoc_data_map.data[line & MAX_SOURCE_LOCATION].locus;
line-map.h to understand what a macro expansion point is. */
static source_location
-linemap_macro_map_loc_to_exp_point (const struct line_map *map,
+linemap_macro_map_loc_to_exp_point (const line_map_macro *map,
source_location location ATTRIBUTE_UNUSED)
{
linemap_assert (linemap_macro_expansion_map_p (map)
macro. */
static source_location
-linemap_macro_map_loc_to_def_point (const struct line_map *map,
+linemap_macro_map_loc_to_def_point (const line_map_macro *map,
source_location location)
{
unsigned token_no;
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,
+linemap_macro_map_loc_unwind_toward_spelling (const line_map_macro* map,
source_location location)
{
unsigned token_no;
linemap_get_expansion_line (struct line_maps *set,
source_location location)
{
- const struct line_map *map = NULL;
+ const line_map_ordinary *map = NULL;
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
linemap_get_expansion_filename (struct line_maps *set,
source_location location)
{
- const struct line_map *map = NULL;
+ const struct line_map_ordinary *map = NULL;
if (IS_ADHOC_LOC (location))
location = set->location_adhoc_data_map.data[location
/* Return the name of the macro associated to MACRO_MAP. */
const char*
-linemap_map_get_macro_name (const struct line_map* macro_map)
+linemap_map_get_macro_name (const line_map_macro *macro_map)
{
linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map));
return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map));
{
if (!linemap_macro_expansion_map_p (map))
/* It's a normal token. */
- return LINEMAP_SYSP (map);
+ return LINEMAP_SYSP (linemap_check_ordinary (map));
else
{
+ const line_map_macro *macro_map = linemap_check_macro (map);
+
/* It's a token resulting from a macro expansion. */
source_location loc =
- linemap_macro_map_loc_unwind_toward_spelling (map, location);
+ linemap_macro_map_loc_unwind_toward_spelling (macro_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);
+ location = linemap_macro_map_loc_to_exp_point (macro_map, location);
else
location = loc;
}
{
if (MAP_START_LOCATION (map0) < MAP_START_LOCATION (map1))
{
- l0 = linemap_macro_map_loc_to_exp_point (map0, l0);
+ l0 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map0),
+ l0);
map0 = linemap_lookup (set, l0);
}
else
{
- l1 = linemap_macro_map_loc_to_exp_point (map1, l1);
+ l1 = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map1),
+ l1);
map1 = linemap_lookup (set, l1);
}
}
/* Print an include trace, for e.g. the -H option of the preprocessor. */
static void
-trace_include (const struct line_maps *set, const struct line_map *map)
+trace_include (const struct line_maps *set, const line_map_ordinary *map)
{
unsigned int i = set->depth;
static source_location
linemap_macro_loc_to_spelling_point (struct line_maps *set,
source_location location,
- const struct line_map **original_map)
+ const line_map_ordinary **original_map)
{
struct line_map *map;
while (true)
{
- map = (struct line_map*) linemap_lookup (set, location);
+ map = const_cast <line_map *> (linemap_lookup (set, location));
if (!linemap_macro_expansion_map_p (map))
break;
- location =
- linemap_macro_map_loc_unwind_toward_spelling (map, location);
+ location
+ = linemap_macro_map_loc_unwind_toward_spelling
+ (linemap_check_macro (map),
+ location);
}
if (original_map)
- *original_map = map;
+ *original_map = linemap_check_ordinary (map);
return location;
}
static source_location
linemap_macro_loc_to_def_point (struct line_maps *set,
source_location location,
- const struct line_map **original_map)
+ const line_map_ordinary **original_map)
{
struct line_map *map;
while (true)
{
- map = (struct line_map*) linemap_lookup (set, location);
+ map = const_cast <line_map *> (linemap_lookup (set, location));
if (!linemap_macro_expansion_map_p (map))
break;
location =
- linemap_macro_map_loc_to_def_point (map, location);
+ linemap_macro_map_loc_to_def_point (linemap_check_macro (map),
+ location);
}
if (original_map)
- *original_map = map;
+ *original_map = linemap_check_ordinary (map);
return location;
}
static source_location
linemap_macro_loc_to_exp_point (struct line_maps *set,
source_location location,
- const struct line_map **original_map)
+ const line_map_ordinary **original_map)
{
struct line_map *map;
while (true)
{
- map = (struct line_map*) linemap_lookup (set, location);
+ map = const_cast <line_map *> (linemap_lookup (set, location));
if (!linemap_macro_expansion_map_p (map))
break;
- location = linemap_macro_map_loc_to_exp_point (map, location);
+ location = linemap_macro_map_loc_to_exp_point (linemap_check_macro (map),
+ location);
}
if (original_map)
- *original_map = map;
+ *original_map = linemap_check_ordinary (map);
return location;
}
linemap_resolve_location (struct line_maps *set,
source_location loc,
enum location_resolution_kind lrk,
- const struct line_map **map)
+ const line_map_ordinary **map)
{
if (IS_ADHOC_LOC (loc))
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
const struct line_map **map)
{
source_location resolved_location;
+ const line_map_macro *macro_map = linemap_check_macro (*map);
const struct line_map *resolved_map;
if (IS_ADHOC_LOC (loc))
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
resolved_location =
- linemap_macro_map_loc_unwind_toward_spelling (*map, loc);
+ linemap_macro_map_loc_unwind_toward_spelling (macro_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_location = linemap_macro_map_loc_to_exp_point (macro_map, loc);
resolved_map = linemap_lookup (set, resolved_location);
}
const struct line_map **map)
{
source_location resolved_loc;
- const struct line_map *map0 = NULL, *map1 = NULL;
+ const struct line_map *map0 = NULL;
+ const line_map_ordinary *map1 = NULL;
if (IS_ADHOC_LOC (loc))
loc = set->location_adhoc_data_map.data[loc & MAX_SOURCE_LOCATION].locus;
if (linemap_location_from_macro_expansion_p (set, loc))
abort ();
- xloc.file = LINEMAP_FILE (map);
- xloc.line = SOURCE_LINE (map, loc);
- xloc.column = SOURCE_COLUMN (map, loc);
- xloc.sysp = LINEMAP_SYSP (map) != 0;
+ const line_map_ordinary *ord_map = linemap_check_ordinary (map);
+
+ xloc.file = LINEMAP_FILE (ord_map);
+ xloc.line = SOURCE_LINE (ord_map, loc);
+ xloc.column = SOURCE_COLUMN (ord_map, loc);
+ xloc.sysp = LINEMAP_SYSP (ord_map) != 0;
}
return xloc;
= { "LC_ENTER", "LC_LEAVE", "LC_RENAME", "LC_RENAME_VERBATIM",
"LC_ENTER_MACRO" };
const char *reason;
- struct line_map *map;
+ const line_map *map;
if (stream == NULL)
stream = stderr;
fprintf (stream, "Map #%u [%p] - LOC: %u - REASON: %s - SYSP: %s\n",
ix, (void *) map, map->start_location, reason,
- (!is_macro && ORDINARY_MAP_IN_SYSTEM_HEADER_P (map)) ? "yes" : "no");
+ ((!is_macro
+ && ORDINARY_MAP_IN_SYSTEM_HEADER_P (linemap_check_ordinary (map)))
+ ? "yes" : "no"));
if (!is_macro)
{
+ const line_map_ordinary *ord_map = linemap_check_ordinary (map);
unsigned includer_ix;
- struct line_map *includer_map;
+ const line_map_ordinary *includer_map;
- includer_ix = ORDINARY_MAP_INCLUDER_FILE_INDEX (map);
+ includer_ix = ORDINARY_MAP_INCLUDER_FILE_INDEX (ord_map);
includer_map = includer_ix < LINEMAPS_ORDINARY_USED (set)
? LINEMAPS_ORDINARY_MAP_AT (set, includer_ix)
: NULL;
- fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (map),
- ORDINARY_MAP_STARTING_LINE_NUMBER (map));
+ fprintf (stream, "File: %s:%d\n", ORDINARY_MAP_FILE_NAME (ord_map),
+ ORDINARY_MAP_STARTING_LINE_NUMBER (ord_map));
fprintf (stream, "Included from: [%d] %s\n", includer_ix,
includer_map ? ORDINARY_MAP_FILE_NAME (includer_map) : "None");
}
else
- fprintf (stream, "Macro: %s (%u tokens)\n",
- linemap_map_get_macro_name (map),
- MACRO_MAP_NUM_MACRO_TOKENS (map));
+ {
+ const line_map_macro *macro_map = linemap_check_macro (map);
+ fprintf (stream, "Macro: %s (%u tokens)\n",
+ linemap_map_get_macro_name (macro_map),
+ MACRO_MAP_NUM_MACRO_TOKENS (macro_map));
+ }
fprintf (stream, "\n");
}
source_location loc,
FILE *stream)
{
- const struct line_map *map;
+ const line_map_ordinary *map;
source_location location;
const char *path = "", *from = "";
int l = -1, c = -1, s = -1, e = -1;
int i;
for (i = set->info_ordinary.used - 1; i >= 0; --i)
{
- const char *fname = set->info_ordinary.maps[i].d.ordinary.to_file;
+ const char *fname = set->info_ordinary.maps[i].to_file;
if (fname && !filename_cmp (fname, file_name))
break;
}
macro_maps_allocated_size, macro_maps_used_size,
macro_maps_locations_size = 0, duplicated_macro_maps_locations_size = 0;
- struct line_map *cur_map;
+ const line_map_macro *cur_map;
ordinary_maps_allocated_size =
- LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map);
+ LINEMAPS_ORDINARY_ALLOCATED (set) * sizeof (struct line_map_ordinary);
ordinary_maps_used_size =
- LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map);
+ LINEMAPS_ORDINARY_USED (set) * sizeof (struct line_map_ordinary);
macro_maps_allocated_size =
- LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map);
+ LINEMAPS_MACRO_ALLOCATED (set) * sizeof (struct line_map_macro);
for (cur_map = LINEMAPS_MACRO_MAPS (set);
cur_map && cur_map <= LINEMAPS_LAST_MACRO_MAP (set);
}
macro_maps_used_size =
- LINEMAPS_MACRO_USED (set) * sizeof (struct line_map);
+ LINEMAPS_MACRO_USED (set) * sizeof (struct line_map_macro);
s->num_ordinary_maps_allocated = LINEMAPS_ORDINARY_ALLOCATED (set);
s->num_ordinary_maps_used = LINEMAPS_ORDINARY_USED (set);
const cpp_token *,
source_location,
source_location,
- const struct line_map *,
+ const line_map_macro *,
unsigned int);
static const cpp_token **tokens_buff_add_token (_cpp_buff *,
const cpp_token *,
source_location,
source_location,
- const struct line_map *,
+ const line_map_macro *,
unsigned int);
static inline void tokens_buff_remove_last_token (_cpp_buff *);
static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
cpp_macro *macro = node->value.macro;
if (!macro->used
- && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
+ && MAIN_FILE_P (linemap_check_ordinary
+ (linemap_lookup (pfile->line_table,
+ macro->line))))
cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0,
"macro \"%s\" is not used", NODE_NAME (node));
}
macro. */
source_location *virt_locs = NULL;
_cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs);
- const line_map * map =
+ const line_map_macro * map =
linemap_enter_macro (pfile->line_table, node,
token->src_loc, 1);
tokens_buff_add_token (token_buf, virt_locs, token,
{
unsigned int i;
const cpp_token *src = macro->exp.tokens;
- const struct line_map *map;
+ const line_map_macro *map;
source_location *virt_locs = NULL;
_cpp_buff *macro_tokens
= tokens_buff_new (pfile, tokens_count, &virt_locs);
_cpp_buff *buff = NULL;
source_location *virt_locs = NULL;
unsigned int exp_count;
- const struct line_map *map = NULL;
+ const line_map_macro *map = NULL;
int track_macro_exp;
/* First, fully macro-expand arguments, calculating the number of
const cpp_token *token,
source_location virt_loc,
source_location parm_def_loc,
- const struct line_map *map,
+ const line_map_macro *map,
unsigned int macro_token_index)
{
source_location macro_loc = virt_loc;
const cpp_token *token,
source_location virt_loc,
source_location parm_def_loc,
- const struct line_map *map,
+ const line_map_macro *map,
unsigned int macro_token_index)
{
const cpp_token **result;
projects / gcc.git / commitdiff