-/* Map logical line numbers to (source file, line number) pairs.
- Copyright (C) 2001, 2003, 2004, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+/* Map (unsigned int) keys to (source file, line, column) triples.
+ Copyright (C) 2001-2015 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
/* The type of line numbers. */
typedef unsigned int linenum_type;
-/* A logical line/column number, i.e. an "index" into a line_map. */
+/* The typedef "source_location" is a key within the location database,
+ identifying a source location or macro expansion.
+
+ This key only has meaning in relation to a line_maps instance. Within
+ gcc there is a single line_maps instance: "line_table", declared in
+ gcc/input.h and defined in gcc/input.c.
+
+ The values of the keys are intended to be internal to libcpp,
+ but for ease-of-understanding the implementation, they are currently
+ assigned as follows:
+
+ Actual | Value | Meaning
+ -----------+-------------------------------+-------------------------------
+ 0x00000000 | | Reserved for use by libcpp
+ 0x00000001 | RESERVED_LOCATION_COUNT - 1 | Reserved for use by libcpp
+ -----------+-------------------------------+-------------------------------
+ 0x00000002 | RESERVED_LOCATION_COUNT | The first location to be
+ | (also | handed out, and the
+ | ordmap[0]->start_location) | first line in ordmap 0
+ -----------+-------------------------------+-------------------------------
+ | ordmap[1]->start_location | First line in ordmap 1
+ | ordmap[1]->start_location+1 | First column in that line
+ | ordmap[1]->start_location+2 | 2nd column in that line
+ | | Subsequent lines are offset by
+ | | (1 << column_bits),
+ | | e.g. 128 for 7 bits, with a
+ | | column value of 0 representing
+ | | "the whole line".
+ | ordmap[2]->start_location-1 | Final location in ordmap 1
+ -----------+-------------------------------+-------------------------------
+ | ordmap[2]->start_location | First line in ordmap 2
+ | ordmap[3]->start_location-1 | Final location in ordmap 2
+ -----------+-------------------------------+-------------------------------
+ | | (etc)
+ -----------+-------------------------------+-------------------------------
+ | ordmap[n-1]->start_location | First line in final ord map
+ | | (etc)
+ | set->highest_location - 1 | Final location in that ordmap
+ -----------+-------------------------------+-------------------------------
+ | set->highest_location | Location of the where the next
+ | | ordinary linemap would start
+ -----------+-------------------------------+-------------------------------
+ | |
+ | VVVVVVVVVVVVVVVVVVVVVVVVVVV
+ | Ordinary maps grow this way
+ |
+ | (unallocated integers)
+ |
+ | Macro maps grow this way
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ -----------+-------------------------------+-------------------------------
+ | LINEMAPS_MACRO_LOWEST_LOCATION| Locations within macro maps
+ | macromap[m-1]->start_location | Start of last macro map
+ | |
+ -----------+-------------------------------+-------------------------------
+ | macromap[m-2]->start_location | Start of penultimate macro map
+ -----------+-------------------------------+-------------------------------
+ | macromap[1]->start_location | Start of macro map 1
+ -----------+-------------------------------+-------------------------------
+ | macromap[0]->start_location | Start of macro map 0
+ 0x7fffffff | MAX_SOURCE_LOCATION |
+ -----------+-------------------------------+-------------------------------
+ 0x80000000 | Start of ad-hoc values |
+ ... | |
+ 0xffffffff | UINT_MAX |
+ -----------+-------------------------------+-------------------------------
+
+ To see how this works in practice, see the worked example in
+ libcpp/location-example.txt. */
typedef unsigned int source_location;
/* Memory allocation function typedef. Works like xrealloc. */
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;
/* This is the highest possible source location encoded within an
ordinary or macro map. */
-#define MAX_SOURCE_LOCATION 0xFFFFFFFF
+const source_location MAX_SOURCE_LOCATION = 0x7FFFFFFF;
struct cpp_hashnode;
/* 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",
Note that a virtual location is a location returned by
linemap_add_macro_token. It encodes the relevant locations (x,y
- pairs) of that token accross the macro expansions from which it
+ pairs) of that token across the macro expansions from which it
(the token) might come from.
In the example above x1 (for token "+") is going to be the same
as y1. x0 is the spelling location for the argument token "1",
and x2 is the spelling location for the argument token "2". */
- source_location * GTY((length ("2 * %h.n_tokens"))) macro_locations;
+ source_location * GTY((atomic)) macro_locations;
/* This is the location of the expansion point of the current macro
map. It's the location of the macro name. That location is held
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.
+#if CHECKING_P && (GCC_VERSION >= 2007)
- A macro map encodes source locations of tokens that are part of a
- macro replacement-list, at a macro expansion point. E.g, in:
+/* Assertion macro to be used in line-map code. */
+#define linemap_assert(EXPR) \
+ do { \
+ if (! (EXPR)) \
+ abort (); \
+ } while (0)
- #define PLUS(A,B) A + B
+/* Assert that becomes a conditional expression when checking is disabled at
+ compilation time. Use this for conditions that should not happen but if
+ they happen, it is better to handle them gracefully rather than crash
+ randomly later.
+ Usage:
- 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.
+ if (linemap_assert_fails(EXPR)) handle_error(); */
+#define linemap_assert_fails(EXPR) __extension__ \
+ ({linemap_assert (EXPR); false;})
- On the other hand, if we later do:
+#else
+/* Include EXPR, so that unused variable warnings do not occur. */
+#define linemap_assert(EXPR) ((void)(0 && (EXPR)))
+#define linemap_assert_fails(EXPR) (! (EXPR))
+#endif
- int a = PLUS (1,2);
+/* Return TRUE if MAP encodes locations coming from a macro
+ replacement-list at macro expansion point. */
+bool
+linemap_macro_expansion_map_p (const struct line_map *);
- 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;
+/* Assert that MAP encodes locations of tokens that are not part of
+ the replacement-list of a macro expansion, downcasting from
+ line_map * to line_map_ordinary *. */
- /* The reason for creation of this line map. */
- ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
+inline line_map_ordinary *
+linemap_check_ordinary (struct line_map *map)
+{
+ linemap_assert (!linemap_macro_expansion_map_p (map));
+ return (line_map_ordinary *)map;
+}
- 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;
-};
+/* Assert that MAP encodes locations of tokens that are not part of
+ the replacement-list of a macro expansion, downcasting from
+ const line_map * to const line_map_ordinary *. */
+
+inline const line_map_ordinary *
+linemap_check_ordinary (const struct line_map *map)
+{
+ linemap_assert (!linemap_macro_expansion_map_p (map));
+ return (const line_map_ordinary *)map;
+}
+
+/* Assert that MAP is a macro expansion and downcast to the appropriate
+ subclass. */
-#define MAP_START_LOCATION(MAP) (MAP)->start_location
+inline line_map_macro *linemap_check_macro (line_map *map)
+{
+ linemap_assert (linemap_macro_expansion_map_p (map));
+ return (line_map_macro *)map;
+}
-#define ORDINARY_MAP_FILE_NAME(MAP) \
- linemap_check_ordinary (MAP)->d.ordinary.to_file
+/* Assert that MAP is a macro expansion and downcast to the appropriate
+ subclass. */
-#define ORDINARY_MAP_STARTING_LINE_NUMBER(MAP) \
- linemap_check_ordinary (MAP)->d.ordinary.to_line
+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;
+}
-#define ORDINARY_MAP_INCLUDER_FILE_INDEX(MAP) \
- linemap_check_ordinary (MAP)->d.ordinary.included_from
+/* Read the start location of MAP. */
-#define ORDINARY_MAP_IN_SYSTEM_HEADER_P(MAP) \
- linemap_check_ordinary (MAP)->d.ordinary.sysp
+inline source_location
+MAP_START_LOCATION (const line_map *map)
+{
+ return map->start_location;
+}
-#define ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(MAP) \
- linemap_check_ordinary (MAP)->d.ordinary.column_bits
+/* Get the starting line number of ordinary map MAP. */
-#define MACRO_MAP_MACRO(MAP) (MAP)->d.macro.macro
+inline linenum_type
+ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map)
+{
+ return ord_map->to_line;
+}
-#define MACRO_MAP_NUM_MACRO_TOKENS(MAP) (MAP)->d.macro.n_tokens
+/* Get the index of the ordinary map at whose end
+ ordinary map MAP was included.
-#define MACRO_MAP_LOCATIONS(MAP) (MAP)->d.macro.macro_locations
+ File(s) at the bottom of the include stack have this set. */
-#define MACRO_MAP_EXPANSION_POINT_LOCATION(MAP) (MAP)->d.macro.expansion
+inline int
+ORDINARY_MAP_INCLUDER_FILE_INDEX (const line_map_ordinary *ord_map)
+{
+ return ord_map->included_from;
+}
+
+/* Return a positive value if map encodes locations from a system
+ header, 0 otherwise. Returns 1 if ordinary map MAP encodes locations
+ in a 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
+ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map)
+{
+ 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_ordinary *ord_map)
+{
+ return ord_map->column_bits;
+}
+
+/* Get the filename of ordinary map MAP. */
+
+inline const char *
+ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map)
+{
+ 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_macro *macro_map)
+{
+ 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_macro *macro_map)
+{
+ 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_macro *macro_map)
+{
+ 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_macro *macro_map)
+{
+ 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;
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;
+
+ /* The number of elements used in maps. This number is smaller
+ or equal to ALLOCATED. */
+ unsigned int used;
+
+ unsigned int cache;
+};
+
+/* Data structure to associate an arbitrary data to a source location. */
+struct GTY(()) location_adhoc_data {
+ source_location locus;
+ void * GTY((skip)) data;
+};
+
+struct htab;
+
+/* The following data structure encodes a location with some adhoc data
+ and maps it to a new unsigned integer (called an adhoc location)
+ that replaces the original location to represent the mapping.
+
+ The new adhoc_loc uses the highest bit as the enabling bit, i.e. if the
+ highest bit is 1, then the number is adhoc_loc. Otherwise, it serves as
+ the original location. Once identified as the adhoc_loc, the lower 31
+ bits of the integer is used to index the location_adhoc_data array,
+ in which the locus and associated data is stored. */
+
+struct GTY(()) location_adhoc_data_map {
+ struct htab * GTY((skip)) htab;
+ source_location curr_loc;
+ unsigned int allocated;
+ struct location_adhoc_data GTY((length ("%h.allocated"))) *data;
+};
+
/* 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;
/* The allocators' function used to know the actual size it
allocated, for a certain allocation size requested. */
line_map_round_alloc_size_func round_alloc_size;
-};
-/* 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. */
-#define LINEMAPS_MAP_INFO(SET, MACRO_MAP_P) \
- ((MACRO_MAP_P) \
- ? &((SET)->info_macro) \
- : &((SET)->info_ordinary))
+ struct location_adhoc_data_map location_adhoc_data_map;
+
+ /* The special location value that is used as spelling location for
+ built-in tokens. */
+ source_location builtin_location;
-/* 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. */
-#define LINEMAPS_MAPS(SET, MAP_KIND) \
- (LINEMAPS_MAP_INFO (SET, MAP_KIND))->maps
+ /* True if we've seen a #line or # 44 "file" directive. */
+ bool seen_line_directive;
+};
/* Returns the number of allocated maps so far. MAP_KIND shall be TRUE
if we are interested in macro maps, FALSE otherwise. */
-#define LINEMAPS_ALLOCATED(SET, MAP_KIND) \
- (LINEMAPS_MAP_INFO (SET, MAP_KIND))->allocated
+inline unsigned int
+LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind)
+{
+ 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)
+{
+ 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
we are interested in macro maps, FALSE otherwise.*/
-#define LINEMAPS_USED(SET, MAP_KIND) \
- (LINEMAPS_MAP_INFO (SET, MAP_KIND))->used
+inline unsigned int
+LINEMAPS_USED (const line_maps *set, bool map_kind)
+{
+ 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)
+{
+ 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
linemap_lookup. MAP_KIND shall be TRUE if we are interested in
macro maps, FALSE otherwise. */
-#define LINEMAPS_CACHE(SET, MAP_KIND) \
- (LINEMAPS_MAP_INFO (SET, MAP_KIND))->cache
+inline unsigned int
+LINEMAPS_CACHE (const line_maps *set, bool map_kind)
+{
+ 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)
+{
+ if (map_kind)
+ return set->info_macro.cache;
+ else
+ return set->info_ordinary.cache;
+}
/* Return the map at a given index. */
-#define LINEMAPS_MAP_AT(SET, MAP_KIND, INDEX) \
- (&((LINEMAPS_MAPS (SET, MAP_KIND))[(INDEX)]))
+inline line_map *
+LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int 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
shall be TRUE if we are interested in macro maps, FALSE
otherwise.*/
-#define LINEMAPS_LAST_MAP(SET, MAP_KIND) \
- LINEMAPS_MAP_AT (SET, MAP_KIND, (LINEMAPS_USED (SET, MAP_KIND) - 1))
+inline line_map *
+LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind)
+{
+ return LINEMAPS_MAP_AT (set, map_kind,
+ LINEMAPS_USED (set, map_kind) - 1);
+}
/* Returns the last map that was allocated in the line table SET.
MAP_KIND shall be TRUE if we are interested in macro maps, FALSE
otherwise.*/
-#define LINEMAPS_LAST_ALLOCATED_MAP(SET, MAP_KIND) \
- LINEMAPS_MAP_AT (SET, MAP_KIND, LINEMAPS_ALLOCATED (SET, MAP_KIND) - 1)
+inline line_map *
+LINEMAPS_LAST_ALLOCATED_MAP (const line_maps *set, bool map_kind)
+{
+ return LINEMAPS_MAP_AT (set, map_kind,
+ LINEMAPS_ALLOCATED (set, map_kind) - 1);
+}
/* Returns a pointer to the memory region where ordinary maps are
allocated in the line table SET. */
-#define LINEMAPS_ORDINARY_MAPS(SET) \
- LINEMAPS_MAPS (SET, false)
+inline line_map_ordinary *
+LINEMAPS_ORDINARY_MAPS (const line_maps *set)
+{
+ return set->info_ordinary.maps;
+}
/* Returns the INDEXth ordinary map. */
-#define LINEMAPS_ORDINARY_MAP_AT(SET, INDEX) \
- LINEMAPS_MAP_AT (SET, false, INDEX)
+inline line_map_ordinary *
+LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int 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
SET. */
-#define LINEMAPS_ORDINARY_ALLOCATED(SET) \
- LINEMAPS_ALLOCATED(SET, false)
+inline unsigned int
+LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set)
+{
+ return LINEMAPS_ALLOCATED (set, false);
+}
/* Return the number of ordinary maps used in the line table SET. */
-#define LINEMAPS_ORDINARY_USED(SET) \
- LINEMAPS_USED(SET, false)
+inline unsigned int
+LINEMAPS_ORDINARY_USED (const line_maps *set)
+{
+ return LINEMAPS_USED (set, false);
+}
/* Return the index of the last ordinary map that was looked up with
linemap_lookup. */
-#define LINEMAPS_ORDINARY_CACHE(SET) \
- LINEMAPS_CACHE(SET, false)
+inline unsigned int
+LINEMAPS_ORDINARY_CACHE (const line_maps *set)
+{
+ return LINEMAPS_CACHE (set, false);
+}
+
+/* As above, but by reference (e.g. as an lvalue). */
+
+inline unsigned int &
+LINEMAPS_ORDINARY_CACHE (line_maps *set)
+{
+ return LINEMAPS_CACHE (set, false);
+}
/* Returns a pointer to the last ordinary map used in the line table
SET. */
-#define LINEMAPS_LAST_ORDINARY_MAP(SET) \
- LINEMAPS_LAST_MAP(SET, false)
+inline line_map_ordinary *
+LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set)
+{
+ return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, false);
+}
/* Returns a pointer to the last ordinary map allocated the line table
SET. */
-#define LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP(SET) \
- LINEMAPS_LAST_ALLOCATED_MAP(SET, false)
+inline line_map_ordinary *
+LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps *set)
+{
+ return (line_map_ordinary *)LINEMAPS_LAST_ALLOCATED_MAP (set, false);
+}
-/* Returns a pointer to the begining of the region where macro maps
+/* Returns a pointer to the beginning of the region where macro maps
are allcoated. */
-#define LINEMAPS_MACRO_MAPS(SET) \
- LINEMAPS_MAPS(SET, true)
+inline line_map_macro *
+LINEMAPS_MACRO_MAPS (const line_maps *set)
+{
+ return set->info_macro.maps;
+}
/* Returns the INDEXth macro map. */
-#define LINEMAPS_MACRO_MAP_AT(SET, INDEX) \
- LINEMAPS_MAP_AT (SET, true, INDEX)
+inline line_map_macro *
+LINEMAPS_MACRO_MAP_AT (const line_maps *set, int 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
table SET. */
-#define LINEMAPS_MACRO_ALLOCATED(SET) \
- LINEMAPS_ALLOCATED(SET, true)
+inline unsigned int
+LINEMAPS_MACRO_ALLOCATED (const line_maps *set)
+{
+ return LINEMAPS_ALLOCATED (set, true);
+}
/* Returns the number of macro maps used in the line table SET. */
-#define LINEMAPS_MACRO_USED(SET) \
- LINEMAPS_USED(SET, true)
+inline unsigned int
+LINEMAPS_MACRO_USED (const line_maps *set)
+{
+ return LINEMAPS_USED (set, true);
+}
/* Returns the index of the last macro map looked up with
linemap_lookup. */
-#define LINEMAPS_MACRO_CACHE(SET) \
- LINEMAPS_CACHE(SET, true)
+inline unsigned int
+LINEMAPS_MACRO_CACHE (const line_maps *set)
+{
+ return LINEMAPS_CACHE (set, true);
+}
-/* Returns the lowest location [of a token resulting from macro
- expansion] encoded in this line table. */
-#define LINEMAPS_MACRO_LOWEST_LOCATION(SET) \
- (LINEMAPS_MACRO_USED (set) \
- ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set)) \
- : MAX_SOURCE_LOCATION)
+/* As above, but by reference (e.g. as an lvalue). */
+
+inline unsigned int &
+LINEMAPS_MACRO_CACHE (line_maps *set)
+{
+ return LINEMAPS_CACHE (set, true);
+}
/* Returns the last macro map used in the line table SET. */
-#define LINEMAPS_LAST_MACRO_MAP(SET) \
- LINEMAPS_LAST_MAP (SET, true)
+inline line_map_macro *
+LINEMAPS_LAST_MACRO_MAP (const line_maps *set)
+{
+ return (line_map_macro *)LINEMAPS_LAST_MAP (set, true);
+}
+
+/* Returns the lowest location [of a token resulting from macro
+ expansion] encoded in this line table. */
+inline source_location
+LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set)
+{
+ return LINEMAPS_MACRO_USED (set)
+ ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set))
+ : MAX_SOURCE_LOCATION;
+}
/* Returns the last macro map allocated in the line table SET. */
-#define LINEMAPS_LAST_ALLOCATED_MACRO_MAP(SET) \
- LINEMAPS_LAST_ALLOCATED_MAP (SET, true)
+inline line_map_macro *
+LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set)
+{
+ return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true);
+}
+
+extern void location_adhoc_data_fini (struct line_maps *);
+extern source_location get_combined_adhoc_loc (struct line_maps *,
+ source_location, void *);
+extern void *get_data_from_adhoc_loc (struct line_maps *, source_location);
+extern source_location get_location_from_adhoc_loc (struct line_maps *,
+ source_location);
-/* Initialize a line map set. */
-extern void linemap_init (struct line_maps *);
+/* Get whether location LOC is an ad-hoc location. */
+
+inline bool
+IS_ADHOC_LOC (source_location loc)
+{
+ return (loc & MAX_SOURCE_LOCATION) != loc;
+}
+
+/* Combine LOC and BLOCK, giving a combined adhoc location. */
+
+inline source_location
+COMBINE_LOCATION_DATA (struct line_maps *set,
+ source_location loc,
+ void *block)
+{
+ return get_combined_adhoc_loc (set, loc, block);
+}
+
+extern void rebuild_location_adhoc_htab (struct line_maps *);
+
+/* Initialize a line map set. SET is the line map set to initialize
+ and BUILTIN_LOCATION is the special location value to be used as
+ spelling location for built-in tokens. This BUILTIN_LOCATION has
+ to be strictly less than RESERVED_LOCATION_COUNT. */
+extern void linemap_init (struct line_maps *set,
+ source_location builtin_location);
/* Check for and warn about line_maps entered but not exited. */
extern const struct line_map *linemap_lookup
(struct line_maps *, source_location);
-/* Returns TRUE if the line table set tracks token locations accross
+/* Returns TRUE if the line table set tracks token locations across
macro expansion, FALSE otherwise. */
bool linemap_tracks_macro_expansion_locs_p (struct line_maps *);
-/* Return TRUE if MAP encodes locations coming from a macro
- replacement-list at macro expansion point. */
-bool linemap_macro_expansion_map_p (const struct line_map *);
-
/* 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
/* Return TRUE if LOCATION is a source code location of a token coming
from a macro replacement-list at a macro expansion point, FALSE
otherwise. */
-bool linemap_location_from_macro_expansion_p (struct line_maps *,
+bool linemap_location_from_macro_expansion_p (const struct line_maps *,
source_location);
/* source_location values from 0 to RESERVED_LOCATION_COUNT-1 will
be reserved for libcpp user as special values, no token from libcpp
will contain any of those locations. */
-#define RESERVED_LOCATION_COUNT 2
+const source_location RESERVED_LOCATION_COUNT = 2;
/* Converts a map and a source_location to source line. */
-#define SOURCE_LINE(MAP, LOC) \
- (((((LOC) - linemap_check_ordinary (MAP)->start_location) \
- >> (MAP)->d.ordinary.column_bits) + (MAP)->d.ordinary.to_line))
+inline linenum_type
+SOURCE_LINE (const line_map_ordinary *ord_map, source_location loc)
+{
+ return ((loc - ord_map->start_location)
+ >> ord_map->column_bits) + ord_map->to_line;
+}
/* Convert a map and source_location to source column number. */
-#define SOURCE_COLUMN(MAP, LOC) \
- ((((LOC) - linemap_check_ordinary (MAP)->start_location) \
- & ((1 << (MAP)->d.ordinary.column_bits) - 1)))
+inline linenum_type
+SOURCE_COLUMN (const line_map_ordinary *ord_map, source_location loc)
+{
+ 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 line_map_ordinary *map)
+{
+ return (((map[1].start_location - 1
+ - map->start_location)
+ & ~((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. */
-#define LAST_SOURCE_LINE(MAP) \
- SOURCE_LINE (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
+inline linenum_type
+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. */
-#define LAST_SOURCE_COLUMN(MAP) \
- SOURCE_COLUMN (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
-/* Return the location of the last source line within an ordinary
- map. */
-#define LAST_SOURCE_LINE_LOCATION(MAP) \
- ((((linemap_check_ordinary (MAP)[1].start_location - 1 \
- - (MAP)->start_location) \
- & ~((1 << (MAP)->d.ordinary.column_bits) - 1)) \
- + (MAP)->start_location))
+inline linenum_type
+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. */
-#define INCLUDED_FROM(SET, MAP) \
- ((linemap_check_ordinary (MAP)->d.ordinary.included_from == -1) \
- ? NULL \
- : (&LINEMAPS_ORDINARY_MAPS (SET)[(MAP)->d.ordinary.included_from]))
-
-/* Nonzero if the map is at the bottom of the include stack. */
-#define MAIN_FILE_P(MAP) \
- ((linemap_check_ordinary (MAP)->d.ordinary.included_from < 0))
-
-#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
+inline line_map_ordinary *
+INCLUDED_FROM (struct line_maps *set, const line_map_ordinary *ord_map)
+{
+ return ((ord_map->included_from == -1)
+ ? NULL
+ : LINEMAPS_ORDINARY_MAP_AT (set, ord_map->included_from));
+}
-/* Assertion macro to be used in line-map code. */
-#define linemap_assert(EXPR) \
- do { \
- if (! (EXPR)) \
- abort (); \
- } while (0)
+/* True if the map is at the bottom of the include stack. */
-/* Assert that MAP encodes locations of tokens that are not part of
- the replacement-list of a macro expansion. */
-#define linemap_check_ordinary(LINE_MAP) __extension__ \
- ({linemap_assert (!linemap_macro_expansion_map_p (LINE_MAP)); \
- (LINE_MAP);})
-#else
-#define linemap_assert(EXPR)
-#define linemap_check_ordinary(LINE_MAP) (LINE_MAP)
-#endif
+inline bool
+MAIN_FILE_P (const line_map_ordinary *ord_map)
+{
+ return ord_map->included_from < 0;
+}
/* Encode and return a source_location from a column number. The
source line considered is the last source line used to call
/* Encode and return a source location from a given line and
column. */
-source_location linemap_position_for_line_and_column (struct line_map *,
- linenum_type,
- unsigned int);
+source_location
+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
+ shifting it by OFFSET columns. This function does not support
+ virtual locations. */
+source_location
+linemap_position_for_loc_and_offset (struct line_maps *set,
+ source_location loc,
+ unsigned int offset);
+
/* Return the file this map is for. */
-#define LINEMAP_FILE(MAP) \
- (linemap_check_ordinary (MAP)->d.ordinary.to_file)
+inline const char *
+LINEMAP_FILE (const line_map_ordinary *ord_map)
+{
+ return ord_map->to_file;
+}
/* Return the line number this map started encoding location from. */
-#define LINEMAP_LINE(MAP) \
- (linemap_check_ordinary (MAP)->d.ordinary.to_line)
+inline linenum_type
+LINEMAP_LINE (const line_map_ordinary *ord_map)
+{
+ return ord_map->to_line;
+}
/* Return a positive value if map encodes locations from a system
header, 0 otherwise. Returns 1 if MAP encodes locations in a
system header and 2 if it encodes locations in a C system header
that therefore needs to be extern "C" protected in C++. */
-#define LINEMAP_SYSP(MAP) \
- (linemap_check_ordinary (MAP)->d.ordinary.sysp)
+inline unsigned char
+LINEMAP_SYSP (const line_map_ordinary *ord_map)
+{
+ return ord_map->sysp;
+}
/* Return a positive value if PRE denotes the location of a token that
comes before the token of POST, 0 if PRE denotes the location of
/* Return TRUE if LOC_A denotes the location a token that comes
topogically before the token denoted by location LOC_B, or if they
are equal. */
-#define linemap_location_before_p(SET, LOC_A, LOC_B) \
- (linemap_compare_locations ((SET), (LOC_A), (LOC_B)) >= 0)
+inline bool
+linemap_location_before_p (struct line_maps *set,
+ source_location loc_a,
+ source_location loc_b)
+{
+ return linemap_compare_locations (set, loc_a, loc_b) >= 0;
+}
typedef struct
{
int column;
+ void *data;
+
/* In a system header?. */
bool sysp;
} expanded_location;
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
long duplicated_macro_maps_locations_size;
};
+/* Return the highest location emitted for a given file for which
+ there is a line map in SET. FILE_NAME is the file name to
+ consider. If the function returns TRUE, *LOC is set to the highest
+ location emitted for that file. */
+bool linemap_get_file_highest_location (struct line_maps * set,
+ const char *file_name,
+ source_location *loc);
+
/* Compute and return statistics about the memory consumption of some
parts of the line table SET. */
void linemap_get_statistics (struct line_maps *, struct linemap_stats *);
projects / gcc.git / blobdiff