/* Map logical line numbers to (source file, line number) pairs.
- Copyright (C) 2001, 2003, 2004, 2007, 2008, 2009
+ Copyright (C) 2001, 2003, 2004, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
#ifndef LIBCPP_LINE_MAP_H
#define LIBCPP_LINE_MAP_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#ifndef GTY
#define GTY(x) /* nothing */
#endif
-/* Reason for adding a line change with add_line_map (). LC_ENTER is
+/* Reason for creating a new line map with linemap_add. LC_ENTER is
when including a new file, e.g. a #include directive in C.
LC_LEAVE is when reaching a file's end. LC_RENAME is when a file
name or line number changes for neither of the above reasons
(e.g. a #line directive in C); LC_RENAME_VERBATIM is like LC_RENAME
- but a filename of "" is not specially interpreted as standard input. */
-enum lc_reason {LC_ENTER = 0, LC_LEAVE, LC_RENAME, LC_RENAME_VERBATIM};
+ but a filename of "" is not specially interpreted as standard
+ input. LC_ENTER_MACRO is when a macro expansion is about to start. */
+enum lc_reason
+{
+ LC_ENTER = 0,
+ LC_LEAVE,
+ LC_RENAME,
+ LC_RENAME_VERBATIM,
+ LC_ENTER_MACRO
+ /* FIXME: add support for stringize and paste. */
+};
/* The type of line numbers. */
typedef unsigned int linenum_type;
/* A logical line/column number, i.e. an "index" into a line_map. */
-/* Long-term, we want to use this to replace struct location_s (in input.h),
- and effectively typedef source_location location_t. */
typedef unsigned int source_location;
/* Memory allocation function typedef. Works like xrealloc. */
typedef void *(*line_map_realloc) (void *, size_t);
-/* Physical source file TO_FILE at line TO_LINE at column 0 is represented
+/* Memory allocator function that returns the actual allocated size,
+ for a given requested allocation. */
+typedef size_t (*line_map_round_alloc_size_func) (size_t);
+
+/* An ordinary line map encodes physical source locations. Those
+ physical source locations are called "spelling locations".
+
+ Physical source file TO_FILE at line TO_LINE at column 0 is represented
by the logical START_LOCATION. TO_LINE+L at column C is represented by
START_LOCATION+(L*(1<<column_bits))+C, as long as C<(1<<column_bits),
and the result_location is less than the next line_map's start_location.
(The top line is line 1 and the leftmost column is column 1; line/column 0
means "entire file/line" or "unknown line/column" or "not applicable".)
- INCLUDED_FROM is an index into the set that gives the line mapping
- at whose end the current one was included. File(s) at the bottom
- of the include stack have this set to -1. REASON is the reason for
- creation of this line map, SYSP is one for a system header, two for
- a C system header file that therefore needs to be extern "C"
- protected in C++, and zero otherwise. */
-struct GTY(()) line_map {
+
+ The highest possible source location is MAX_SOURCE_LOCATION. */
+struct GTY(()) line_map_ordinary {
const char *to_file;
linenum_type to_line;
- source_location start_location;
+
+ /* An index into the set that gives the line mapping at whose end
+ the current one was included. File(s) at the bottom of the
+ include stack have this set to -1. */
int included_from;
- ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
- /* The sysp field isn't really needed now that it's in cpp_buffer. */
+
+ /* SYSP is one for a system header, two for a C system header file
+ that therefore needs to be extern "C" protected in C++, and zero
+ otherwise. This field isn't really needed now that it's in
+ cpp_buffer. */
unsigned char sysp;
+
/* Number of the low-order source_location bits used for a column number. */
unsigned int column_bits : 8;
};
-/* A set of chronological line_map structures. */
-struct GTY(()) line_maps {
+/* This is the highest possible source location encoded within an
+ ordinary or macro map. */
+#define MAX_SOURCE_LOCATION 0xFFFFFFFF
+
+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 {
+ /* 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",
+ "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
+ macro;
+
+ /* The number of tokens inside the replacement-list of MACRO. */
+ unsigned int n_tokens;
+
+ /* This array of location is actually an array of pairs of
+ locations. The elements inside it thus look like:
+
+ x0,y0, x1,y1, x2,y2, ...., xn,yn.
+
+ where n == n_tokens;
+
+ Remember that these xI,yI are collected when libcpp is about to
+ expand a given macro.
+
+ yI is the location in the macro definition, either of the token
+ itself or of a macro parameter that it replaces.
+
+ Imagine this:
+
+ #define PLUS(A, B) A + B <--- #1
+
+ int a = PLUS (1,2); <--- #2
+
+ There is a macro map for the expansion of PLUS in #2. PLUS is
+ expanded into its expansion-list. The expansion-list is the
+ replacement-list of PLUS where the macro parameters are replaced
+ with their arguments. So the replacement-list of PLUS is made of
+ the tokens:
+
+ A, +, B
+
+ and the expansion-list is made of the tokens:
+
+ 1, +, 2
+
+ Let's consider the case of token "+". Its y1 [yI for I == 1] is
+ its spelling location in #1.
+
+ y0 (thus for token "1") is the spelling location of A in #1.
+
+ And y2 (of token "2") is the spelling location of B in #1.
+
+ When the token is /not/ an argument for a macro, xI is the same
+ location as yI. Otherwise, xI is the location of the token
+ outside this macro expansion. If this macro was expanded from
+ another macro expansion, xI is a virtual location representing
+ the token in that macro expansion; otherwise, it is the spelling
+ location of the token.
+
+ 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
+ (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;
+
+ /* 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
+ by the map that was current right before the current one. It
+ could have been either a macro or an ordinary map, depending on
+ if we are in a nested expansion context not. */
+ 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;
+};
+
+#define MAP_START_LOCATION(MAP) (MAP)->start_location
+
+#define ORDINARY_MAP_FILE_NAME(MAP) \
+ linemap_check_ordinary (MAP)->d.ordinary.to_file
+
+#define ORDINARY_MAP_STARTING_LINE_NUMBER(MAP) \
+ linemap_check_ordinary (MAP)->d.ordinary.to_line
+
+#define ORDINARY_MAP_INCLUDER_FILE_INDEX(MAP) \
+ linemap_check_ordinary (MAP)->d.ordinary.included_from
+
+#define ORDINARY_MAP_IN_SYSTEM_HEADER_P(MAP) \
+ linemap_check_ordinary (MAP)->d.ordinary.sysp
+
+#define ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(MAP) \
+ linemap_check_ordinary (MAP)->d.ordinary.column_bits
+
+#define MACRO_MAP_MACRO(MAP) (MAP)->d.macro.macro
+
+#define MACRO_MAP_NUM_MACRO_TOKENS(MAP) (MAP)->d.macro.n_tokens
+
+#define MACRO_MAP_LOCATIONS(MAP) (MAP)->d.macro.macro_locations
+
+#define MACRO_MAP_EXPANSION_POINT_LOCATION(MAP) (MAP)->d.macro.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;
+
+ /* 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;
+};
+
+/* A set of chronological line_map structures. */
+struct GTY(()) line_maps {
+
+ struct maps_info info_ordinary;
- /* The most recently listed include stack, if any, starts with
- LAST_LISTED as the topmost including file. -1 indicates nothing
- has been listed yet. */
- int last_listed;
+ struct maps_info info_macro;
/* Depth of the include stack, including the current file. */
unsigned int depth;
/* If non-null, the allocator to use when resizing 'maps'. If null,
xrealloc is used. */
line_map_realloc reallocator;
+
+ /* 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))
+
+/* 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
+
+/* 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
+
+/* 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
+
+/* 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
+
+/* Return the map at a given index. */
+#define LINEMAPS_MAP_AT(SET, MAP_KIND, INDEX) \
+ (&((LINEMAPS_MAPS (SET, MAP_KIND))[(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))
+
+/* 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)
+
+/* 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)
+
+/* Returns the INDEXth ordinary map. */
+#define LINEMAPS_ORDINARY_MAP_AT(SET, INDEX) \
+ LINEMAPS_MAP_AT (SET, false, INDEX)
+
+/* Return the number of ordinary maps allocated in the line table
+ SET. */
+#define LINEMAPS_ORDINARY_ALLOCATED(SET) \
+ 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)
+
+/* Return the index of the last ordinary map that was looked up with
+ linemap_lookup. */
+#define LINEMAPS_ORDINARY_CACHE(SET) \
+ 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)
+
+/* 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)
+
+/* Returns a pointer to the begining of the region where macro maps
+ are allcoated. */
+#define LINEMAPS_MACRO_MAPS(SET) \
+ LINEMAPS_MAPS(SET, true)
+
+/* Returns the INDEXth macro map. */
+#define LINEMAPS_MACRO_MAP_AT(SET, INDEX) \
+ LINEMAPS_MAP_AT (SET, true, INDEX)
+
+/* Returns the number of macro maps that were allocated in the line
+ table SET. */
+#define LINEMAPS_MACRO_ALLOCATED(SET) \
+ 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)
+
+/* Returns the index of the last macro map looked up with
+ linemap_lookup. */
+#define LINEMAPS_MACRO_CACHE(SET) \
+ 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)
+
+/* Returns the last macro map used in the line table SET. */
+#define LINEMAPS_LAST_MACRO_MAP(SET) \
+ LINEMAPS_LAST_MAP (SET, true)
+
+/* Returns the last macro map allocated in the line table SET. */
+#define LINEMAPS_LAST_ALLOCATED_MACRO_MAP(SET) \
+ LINEMAPS_LAST_ALLOCATED_MAP (SET, true)
+
/* Initialize a line map set. */
extern void linemap_init (struct line_maps *);
-/* Free a line map set. */
-extern void linemap_free (struct line_maps *);
-
/* Check for and warn about line_maps entered but not exited. */
extern void linemap_check_files_exited (struct line_maps *);
(struct line_maps *set, linenum_type to_line, unsigned int max_column_hint);
/* Add a mapping of logical source line to physical source file and
- line number.
+ line number. This function creates an "ordinary map", which is a
+ map that records locations of tokens that are not part of macro
+ replacement-lists present at a macro expansion point.
The text pointed to by TO_FILE must have a lifetime
- at least as long as the final call to lookup_line (). An empty
+ at least as long as the lifetime of SET. An empty
TO_FILE means standard input. If reason is LC_LEAVE, and
TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
natural values considering the file we are returning to.
(struct line_maps *, enum lc_reason, unsigned int sysp,
const char *to_file, linenum_type to_line);
-/* Given a logical line, returns the map from which the corresponding
- (source file, line) pair can be deduced. */
+/* Given a logical source location, returns the map which the
+ corresponding (source file, line, column) triplet can be deduced
+ from. Since the set is built chronologically, the logical lines are
+ monotonic increasing, and so the list is sorted and we can use a
+ binary search. If no line map have been allocated yet, this
+ function returns NULL. */
extern const struct line_map *linemap_lookup
(struct line_maps *, source_location);
-/* Converts a map and a source_location to source line. */
-#define SOURCE_LINE(MAP, LOC) \
- ((((LOC) - (MAP)->start_location) >> (MAP)->column_bits) + (MAP)->to_line)
+/* Returns TRUE if the line table set tracks token locations accross
+ 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*);
+
+/* 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
+ is the locus of a token that is located in a system header, and 2
+ if LOCATION is the locus of a token located in a C system header
+ that therefore needs to be extern "C" protected in C++.
+
+ Note that this function returns 1 if LOCATION belongs to a token
+ that is part of a macro replacement-list defined in a system
+ header, but expanded in a non-system file. */
+int linemap_location_in_system_header_p (struct line_maps *,
+ source_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 *,
+ source_location);
-#define SOURCE_COLUMN(MAP, LOC) \
- (((LOC) - (MAP)->start_location) & ((1 << (MAP)->column_bits) - 1))
+/* 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
-/* Returns the last source line within a map. This is the (last) line
- of the #include, or other directive, that caused a map change. */
+/* 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))
+
+/* 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)))
+
+/* 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))
+
+/* Return the last column number within an ordinary map. */
#define LAST_SOURCE_COLUMN(MAP) \
SOURCE_COLUMN (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
-#define LAST_SOURCE_LINE_LOCATION(MAP) \
- ((((MAP)[1].start_location - 1 - (MAP)->start_location) \
- & ~((1 << (MAP)->column_bits) - 1)) \
- + (MAP)->start_location)
-/* Returns the map a given map was included from. */
-#define INCLUDED_FROM(SET, MAP) (&(SET)->maps[(MAP)->included_from])
+/* 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))
+
+/* 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) ((MAP)->included_from < 0)
-
-/* Set LOC to a source position that is the same line as the most recent
- linemap_line_start, but with the specified TO_COLUMN column number. */
-
-#define LINEMAP_POSITION_FOR_COLUMN(LOC, SET, TO_COLUMN) do { \
- unsigned int to_column = (TO_COLUMN); \
- struct line_maps *set = (SET); \
- if (__builtin_expect (to_column >= set->max_column_hint, 0)) \
- (LOC) = linemap_position_for_column (set, to_column); \
- else { \
- source_location r = set->highest_line; \
- r = r + to_column; \
- if (r >= set->highest_location) \
- set->highest_location = r; \
- (LOC) = r; \
- }} while (0)
-
+#define MAIN_FILE_P(MAP) \
+ ((linemap_check_ordinary (MAP)->d.ordinary.included_from < 0))
+
+#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
+
+/* Assertion macro to be used in line-map code. */
+#define linemap_assert(EXPR) \
+ do { \
+ if (! (EXPR)) \
+ abort (); \
+ } while (0)
+
+/* 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
+/* Encode and return a source_location from a column number. The
+ source line considered is the last source line used to call
+ linemap_line_start, i.e, the last source line which a location was
+ encoded from. */
extern source_location
-linemap_position_for_column (struct line_maps *set, unsigned int to_column);
+linemap_position_for_column (struct line_maps *, unsigned int);
+
+/* 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);
+/* Return the file this map is for. */
+#define LINEMAP_FILE(MAP) \
+ (linemap_check_ordinary (MAP)->d.ordinary.to_file)
+
+/* Return the line number this map started encoding location from. */
+#define LINEMAP_LINE(MAP) \
+ (linemap_check_ordinary (MAP)->d.ordinary.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)
+
+/* 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
+ the same token as the token for POST, and a negative value
+ otherwise. */
+int linemap_compare_locations (struct line_maps *set,
+ source_location pre,
+ source_location post);
+
+/* 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)
+
+typedef struct
+{
+ /* The name of the source file involved. */
+ const char *file;
+
+ /* The line-location in the source file. */
+ int line;
+
+ int column;
+
+ /* In a system header?. */
+ bool sysp;
+} expanded_location;
+
+/* This is enum is used by the function linemap_resolve_location
+ below. The meaning of the values is explained in the comment of
+ that function. */
+enum location_resolution_kind
+{
+ LRK_MACRO_EXPANSION_POINT,
+ LRK_SPELLING_LOCATION,
+ LRK_MACRO_DEFINITION_LOCATION
+};
-#ifdef __cplusplus
-}
-#endif
+/* Resolve a virtual location into either a spelling location, an
+ expansion point location or a token argument replacement point
+ location. Return the map that encodes the virtual location as well
+ as the resolved location.
+
+ If LOC is *NOT* the location of a token resulting from the
+ expansion of a macro, then the parameter LRK (which stands for
+ Location Resolution Kind) is ignored and the resulting location
+ just equals the one given in argument.
+
+ Now if LOC *IS* the location of a token resulting from the
+ expansion of a macro, this is what happens.
+
+ * If LRK is set to LRK_MACRO_EXPANSION_POINT
+ -------------------------------
+
+ The virtual location is resolved to the first macro expansion point
+ that led to this macro expansion.
+
+ * If LRK is set to LRK_SPELLING_LOCATION
+ -------------------------------------
+
+ The virtual location is resolved to the locus where the token has
+ been spelled in the source. This can follow through all the macro
+ expansions that led to the token.
+
+ * If LRK is set to LRK_MACRO_DEFINITION_LOCATION
+ --------------------------------------
+
+ The virtual location is resolved to the locus of the token in the
+ context of the macro definition.
+
+ If LOC is the locus of a token that is an argument of a
+ function-like macro [replacing a parameter in the replacement list
+ of the macro] the virtual location is resolved to the locus of the
+ parameter that is replaced, in the context of the definition of the
+ macro.
+
+ If LOC is the locus of a token that is not an argument of a
+ function-like macro, then the function behaves as if LRK was set to
+ LRK_SPELLING_LOCATION.
+
+ If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the
+ returned location. Note that if the resturned location wasn't originally
+ encoded by a map, the *MAP is set to NULL. This can happen if LOC
+ resolves to a location reserved for the client code, like
+ UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */
+
+source_location linemap_resolve_location (struct line_maps *,
+ source_location loc,
+ enum location_resolution_kind lrk,
+ const struct line_map **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
+ location L of the point where M got expanded. If L is a spelling
+ location inside a macro expansion M', then this function returns
+ the point where M' was expanded. LOC_MAP is an output parameter.
+ When non-NULL, *LOC_MAP is set the the map of the returned
+ location. */
+source_location linemap_unwind_toward_expansion (struct line_maps *,
+ source_location loc,
+ const struct line_map **loc_map);
+
+/* Expand source code location LOC and return a user readable source
+ code location. LOC must be a spelling (non-virtual) location. If
+ it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
+ location is returned. */
+expanded_location linemap_expand_location (struct line_maps *,
+ const struct line_map *,
+ source_location loc);
+
+/* Statistics about maps allocation and usage as returned by
+ linemap_get_statistics. */
+struct linemap_stats
+{
+ long num_ordinary_maps_allocated;
+ long num_ordinary_maps_used;
+ long ordinary_maps_allocated_size;
+ long ordinary_maps_used_size;
+ long num_expanded_macros;
+ long num_macro_tokens;
+ long num_macro_maps_used;
+ long macro_maps_allocated_size;
+ long macro_maps_used_size;
+ long macro_maps_locations_size;
+ long duplicated_macro_maps_locations_size;
+};
+
+/* 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 *);
+
+/* Dump debugging information about source location LOC into the file
+ stream STREAM. SET is the line map set LOC comes from. */
+void linemap_dump_location (struct line_maps *, source_location, FILE *);
+
+/* Dump line map at index IX in line table SET to STREAM. If STREAM
+ is NULL, use stderr. IS_MACRO is true if the caller wants to
+ dump a macro map, false otherwise. */
+void linemap_dump (FILE *, struct line_maps *, unsigned, bool);
+
+/* Dump line table SET to STREAM. If STREAM is NULL, stderr is used.
+ NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO
+ specifies how many macro maps to dump. */
+void line_table_dump (FILE *, struct line_maps *, unsigned int, unsigned int);
#endif /* !LIBCPP_LINE_MAP_H */
OSDN Git Service
