Patchwork [1/6] Linemap infrastructure for virtual locations

login
register
mail settings
Submitter Dodji Seketeli
Date Dec. 10, 2010, 11:11 a.m.
Message ID <1291979498-1604-3-git-send-email-dodji@redhat.com>
Download mbox | patch
Permalink /patch/75081/
State New
Headers show

Comments

Dodji Seketeli - Dec. 10, 2010, 11:11 a.m.
This is the first instalment of a set which goal is to track locations
of tokens across macro expansions. Tom Tromey did the original work
and attached the patch to PR preprocessor/7263. This opus is a
derivative of that original work.

This patch modifies the linemap module of libcpp to add virtual
locations support.

A virtual location is a mapped location that can resolve to several
Tom Tromey - Jan. 6, 2011, 4:24 p.m.
>>>>> "Dodji" == Dodji Seketeli <dodji@redhat.com> writes:

Dodji> This is the first instalment of a set which goal is to track locations
Dodji> of tokens across macro expansions. Tom Tromey did the original work
Dodji> and attached the patch to PR preprocessor/7263. This opus is a
Dodji> derivative of that original work.

Thank you very much for doing this.

I think the accessor macros and changes to use them could go in as a
separate patch.  It doesn't matter too much now, but I think this would
have made this patch more readable.

Dodji>    expanded_location xloc;
Dodji>    if (loc <= BUILTINS_LOCATION)
Dodji> -    {
Dodji> -      xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>");
Dodji> +    {      
Dodji> +      /* If LOC is UNKNOWN_LOCATION and there was a map allocated for
Dodji> +	 it then XLOC.FILE should be the file path of the map,
Dodji> +	 i.e. the file path of the main file being compiled.
Dodji> +	 Otherwise [if we are being called before any line map has
Dodji> +	 been allocated, e.g. during parsing of commande line
Dodji> +	 options] if no line map has been allocated yet, then
Dodji> +	 XLOC.FILE should just be NULL.  */
Dodji> +      if (loc == UNKNOWN_LOCATION)
Dodji> +	{
Dodji> +	  const struct line_map *map =
Dodji> +	    linemap_lookup (line_table, UNKNOWN_LOCATION);
Dodji> +	  xloc.file = map != NULL ? LINEMAP_FILE (map) : NULL;
Dodji> +	}

I don't understand this.  I thought that UNKNOWN_LOCATION should never
have an associated file.  This is handled in a funny way: each front end
is responsible for ensuring that this holds true (this could be cleaned
up...).

Am I mistaken about this?  Or is something weird happening after this
patch?

Dodji> @@ -883,14 +884,14 @@ static void
Dodji>  do_line (cpp_reader *pfile)
Dodji>  {
Dodji>    const struct line_maps *line_table = pfile->line_table;
Dodji> -  const struct line_map *map = &line_table->maps[line_table->used - 1];
Dodji> +  const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
 
Dodji>    /* skip_rest_of_line() may cause line table to be realloc()ed so note down
Dodji>       sysp right now.  */
 
Dodji> -  unsigned char map_sysp = map->sysp;
Dodji> +  unsigned char map_sysp = map->d.ordinary.sysp;
Dodji>    const cpp_token *token;
Dodji> -  const char *new_file = map->to_file;
Dodji> +  const char *new_file = map->d.ordinary.to_file;

Did you want to use the accessor macros here?
If not, why not?

Dodji>    /* C99 raised the minimum limit on #line numbers.  */
Dodji> @@ -945,11 +946,11 @@ static void
Dodji>  do_linemarker (cpp_reader *pfile)
Dodji>  {
Dodji>    const struct line_maps *line_table = pfile->line_table;
Dodji> -  const struct line_map *map = &line_table->maps[line_table->used - 1];
Dodji> +  const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
Dodji>    const cpp_token *token;
Dodji> -  const char *new_file = map->to_file;
Dodji> +  const char *new_file = map->d.ordinary.to_file;
Dodji>    linenum_type new_lineno;
Dodji> -  unsigned int new_sysp = map->sysp;
Dodji> +  unsigned int new_sysp = map->d.ordinary.sysp;

Likewise.

Dodji>    if (map != NULL)
Dodji> -    linemap_line_start (pfile->line_table, map->to_line, 127);
Dodji> +    linemap_line_start (pfile->line_table, map->d.ordinary.to_line, 127);

Likewise.

Dodji> +  int sysp = (LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table) > 1)
Dodji> +    && (pfile->buffer ? pfile->buffer->sysp : 0);

The indentation is off here.
Put another paren after the '=' and emacs will DTRT.

Dodji> +   physicall source locations are called "spelling locations".

Typo, should be "physical".

Dodji> +/* A set of chronological line_map structures.  */
Dodji> +struct GTY(()) line_maps {
Dodji> +  
Dodji> +  struct maps_info info_ordinary;
Dodji> +
Dodji> +  struct maps_info info_macro;

One thing to note is that there may be some code that assumes an
ordering of location values.  If you hand out ordinary and macro
locations separately (which I think is what is going on), then code
doing this may break.

My recollection is that maybe the diagnostic code did this?
Or maybe it was someplace more obscure :-(
Did you happen to run across this while working on this patch?

Dodji> -      fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
Dodji> +      fname = (LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table))->d.ordinary.to_file;

Accessor?

Dodji> +/* Add a mapping of logical source line to physical source file and
Dodji> +   line number. This function creates an "ordinary map", which is a
Dodji> +   map that records locations of tokens that are not part of macro
Dodji> +   replacement-lists present at a macro expansion point.
Dodji> +
Dodji> +   The text pointed to by TO_FILE must have a lifetime
Dodji> +   at least as long as the lifetime of SET.  An empty
Dodji> +   TO_FILE means standard input.  If reason is LC_LEAVE, and
Dodji> +   TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
Dodji> +   natural values considering the file we are returning to.
Dodji> +
Dodji> +   A call to this function can relocate the previous set of
Dodji> +   maps, so any stored line_map pointers should not be used.  */
Dodji> +
Dodji> +const struct line_map *
Dodji> +linemap_add (struct line_maps *set, enum lc_reason reason,
Dodji> +	     unsigned int sysp, const char *to_file, linenum_type to_line)

I would generally prefer for explanatory comments for public functions
to be in the header, not by the implementation.  This is more in keeping
with the current style of the line map code, but I also like it because
it provides a single text for users of the library to read.

Nice job on the comments, btw.

Tom
Dodji Seketeli - April 12, 2011, 2:39 p.m.
Hello,

Sorry for getting back to this just now, and thank you very much for the
review.  Please find below my reply to your comments.

Tom Tromey <tromey@redhat.com> writes:

> Dodji>    expanded_location xloc;
> Dodji>    if (loc <= BUILTINS_LOCATION)
> Dodji> -    {
> Dodji> -      xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>");
> Dodji> +    {      
> Dodji> +      /* If LOC is UNKNOWN_LOCATION and there was a map allocated for
> Dodji> +	 it then XLOC.FILE should be the file path of the map,
> Dodji> +	 i.e. the file path of the main file being compiled.
> Dodji> +	 Otherwise [if we are being called before any line map has
> Dodji> +	 been allocated, e.g. during parsing of commande line
> Dodji> +	 options] if no line map has been allocated yet, then
> Dodji> +	 XLOC.FILE should just be NULL.  */
> Dodji> +      if (loc == UNKNOWN_LOCATION)
> Dodji> +	{
> Dodji> +	  const struct line_map *map =
> Dodji> +	    linemap_lookup (line_table, UNKNOWN_LOCATION);
> Dodji> +	  xloc.file = map != NULL ? LINEMAP_FILE (map) : NULL;
> Dodji> +	}
> 
> I don't understand this.  I thought that UNKNOWN_LOCATION should never
> have an associated file.  This is handled in a funny way: each front end
> is responsible for ensuring that this holds true (this could be cleaned
> up...).
> 
> Am I mistaken about this?  Or is something weird happening after this
> patch?

I was confused.  I realize now this was some papering over what I later
realized was PR preprocessor/48532, that I filed separately along with a
patch.  I have thus removed this hunk from my local copy of the patch.

> 
> Dodji> @@ -883,14 +884,14 @@ static void
> Dodji>  do_line (cpp_reader *pfile)
> Dodji>  {
> Dodji>    const struct line_maps *line_table = pfile->line_table;
> Dodji> -  const struct line_map *map = &line_table->maps[line_table->used - 1];
> Dodji> +  const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
>  
> Dodji>    /* skip_rest_of_line() may cause line table to be realloc()ed so note down
> Dodji>       sysp right now.  */
>  
> Dodji> -  unsigned char map_sysp = map->sysp;
> Dodji> +  unsigned char map_sysp = map->d.ordinary.sysp;
> Dodji>    const cpp_token *token;
> Dodji> -  const char *new_file = map->to_file;
> Dodji> +  const char *new_file = map->d.ordinary.to_file;
> 
> Did you want to use the accessor macros here?
> If not, why not?

Oops.  Yes of course I wanted to use the accessor macros there.  I have
just done it on my local copy of the patch now.  Thanks.

> 
> Dodji>    /* C99 raised the minimum limit on #line numbers.  */
> Dodji> @@ -945,11 +946,11 @@ static void
> Dodji>  do_linemarker (cpp_reader *pfile)
> Dodji>  {
> Dodji>    const struct line_maps *line_table = pfile->line_table;
> Dodji> -  const struct line_map *map = &line_table->maps[line_table->used - 1];
> Dodji> +  const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
> Dodji>    const cpp_token *token;
> Dodji> -  const char *new_file = map->to_file;
> Dodji> +  const char *new_file = map->d.ordinary.to_file;
> Dodji>    linenum_type new_lineno;
> Dodji> -  unsigned int new_sysp = map->sysp;
> Dodji> +  unsigned int new_sysp = map->d.ordinary.sysp;
> 
> Likewise.
> 
> Dodji>    if (map != NULL)
> Dodji> -    linemap_line_start (pfile->line_table, map->to_line, 127);
> Dodji> +    linemap_line_start (pfile->line_table, map->d.ordinary.to_line, 127);
> 
> Likewise.
> 
> Dodji> +  int sysp = (LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table) > 1)
> Dodji> +    && (pfile->buffer ? pfile->buffer->sysp : 0);
> 
> The indentation is off here.
> Put another paren after the '=' and emacs will DTRT.

Done, thanks.

> 
> Dodji> +   physicall source locations are called "spelling locations".
> 
> Typo, should be "physical".
> 
> Dodji> +/* A set of chronological line_map structures.  */
> Dodji> +struct GTY(()) line_maps {
> Dodji> +  
> Dodji> +  struct maps_info info_ordinary;
> Dodji> +
> Dodji> +  struct maps_info info_macro;
> 
> One thing to note is that there may be some code that assumes an
> ordering of location values.  If you hand out ordinary and macro
> locations separately (which I think is what is going on), then code
> doing this may break.

Argh.  The reason why I am doing this is to avoid the (huge) increase of
memory usage due to the fact that the presence of a macro map was
triggering the creation of one more standard map.  Given the number of
macros in some TU, that was starting to add up.  We have discussed this
off-line and a possible way to avoid that was to separate the "integer
space" of locations mapped into macro maps from the integer space of
locations mapped into ordinary maps.  Of course, locations from a given
integer space (be it the space of macro tokens locations or ordinary
token location) is ordered.  This also eases the map lookup as a simple
comparisons is enough to know if a given location is of a token coming
from a macro expansion or not.

Now I think I am left with two options, I guess.  Either I find a way to
make the two kind of locations (those mapped into macro maps and those
mapped into ordinary maps) share the same integer space and be ordered,
or, I spot the places in the code that assume an ordering of all
location values and I change that.

Is the location ordering a strong property we want to keep?

> 
> My recollection is that maybe the diagnostic code did this?
> Or maybe it was someplace more obscure :-(
> Did you happen to run across this while working on this patch?

I haven't noticed that with my tests.  But after reading this, I have
found one spot of the in diagnostic_report_diagnostic that does this.  I
don't know yet if there are other places.

> 
> Dodji> -      fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
> Dodji> +      fname = (LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table))->d.ordinary.to_file;
> 
> Accessor?

Oops, fixed in my local copy of the patch.

> 
> Dodji> +/* Add a mapping of logical source line to physical source file and
> Dodji> +   line number. This function creates an "ordinary map", which is a
> Dodji> +   map that records locations of tokens that are not part of macro
> Dodji> +   replacement-lists present at a macro expansion point.
> Dodji> +
> Dodji> +   The text pointed to by TO_FILE must have a lifetime
> Dodji> +   at least as long as the lifetime of SET.  An empty
> Dodji> +   TO_FILE means standard input.  If reason is LC_LEAVE, and
> Dodji> +   TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
> Dodji> +   natural values considering the file we are returning to.
> Dodji> +
> Dodji> +   A call to this function can relocate the previous set of
> Dodji> +   maps, so any stored line_map pointers should not be used.  */
> Dodji> +
> Dodji> +const struct line_map *
> Dodji> +linemap_add (struct line_maps *set, enum lc_reason reason,
> Dodji> +	     unsigned int sysp, const char *to_file, linenum_type to_line)
> 
> I would generally prefer for explanatory comments for public functions
> to be in the header, not by the implementation.  This is more in keeping
> with the current style of the line map code, but I also like it because
> it provides a single text for users of the library to read.

Ah.  I did this because:

     - I thought it was in line of the rest of the code of libcpp (and
       GCC).  I didn't realize it was done on purpose in line-map.h
       only.
     - Having the documentation be at the place where etags points you
       to when you look for a function seemed very convenient to me.  -
       It seems to me that having the documentation near the definition
       helps in keeping the document and the definition in sync.

But if you want, I can just move the the comments to the header file,
no problem at all.
Tom Tromey - April 14, 2011, 2:45 p.m.
>>>>> "Dodji" == Dodji Seketeli <dodji@redhat.com> writes:

Tom> One thing to note is that there may be some code that assumes an
Tom> ordering of location values.  If you hand out ordinary and macro
Tom> locations separately (which I think is what is going on), then code
Tom> doing this may break.

[...]
Dodji> Now I think I am left with two options, I guess.  Either I find a way to
Dodji> make the two kind of locations (those mapped into macro maps and those
Dodji> mapped into ordinary maps) share the same integer space and be ordered,
Dodji> or, I spot the places in the code that assume an ordering of all
Dodji> location values and I change that.

Dodji> Is the location ordering a strong property we want to keep?

It doesn't matter to me.  I think it would probably be sufficient if
there were a "cheap-enough" comparison function.

Dodji> I haven't noticed that with my tests.  But after reading this, I have
Dodji> found one spot of the in diagnostic_report_diagnostic that does this.  I
Dodji> don't know yet if there are other places.

Too bad we can't just write operator< :-)

Dodji> But if you want, I can just move the the comments to the header file,
Dodji> no problem at all.

Yeah, please do.

Tom

Patch

different physical locations. It can always resolve to the spelling
location of a token. For tokens resulting from macro expansion it can
resolve to:
  - either the location of the expansion point of the macro.
  - or the location of the token in the definition of the
  macro
  - or, if the token is an argument of a function-like macro,
  the location of the use of the matching macro parameter in
  the definition of the macro

The patch creates a new type of line map called a macro map. For every
single macro expansion, there is a macro map that generates a virtual
location for every single resulting token of the expansion.

The good old type of line map we all know is now called an ordinary
map. That one still encodes spelling locations as it has always had.

As a result linemap_lookup as been extended to return a macro map when
given a virtual location resulting from a macro expansion. The layout
of structs line_map has changed to support this new type of map. So
did the layout of struct line_maps. Accessor macros have been
introduced to avoid messing with the implementation details of these
datastructures directly. This helped already as we have been testing
different ways of arranging these datastructure. Having to constantly
adjust client code that is too tied with the internals of line_map and
line_maps would have been even more painful.

Of course, many new public functions have been added to the linemap
module to handle the resolution of virtual locations.

This patch introduces the infrastructure but no part of the compiler
uses virtual locations yet.

However the client code of the linemap data structures has been
adjusted as per the changes. E.g, it's not anymore reliable for a
client code to manipulate struct line_map directly if it just wants to
deal with spelling locations, because struct line_map can now
represent a macro map as well. In that case, it's better to use the
convenient API to resolve the initial (possibly virtual) location to a
spelling location (or to an ordinary map) and use that.

This is the reason why the patch adjusts the Java, Ada and Fortran
front ends.

The patch does not introduce any regression test because it doesn't
introduce any use of virtual locations at the compiler level yet.

Boostrapped with --enable-languages=all,ada and passed regression
tests on x86_unknown-linux-gnu against trunk.

libcpp/

	* include/cpp-id-data.h (struct cpp_macro)<name>: New field for
	diagnostics purposes.
	* include/line-map.h (enum lc_reason)<LC_ENTER_MACRO>: New enum
	member.
	(MAX_SOURCE_LOCATION): New constant.
	(struct line_map_ordinary, struct line_map_macro): New structs.
	(struct line_map): Turn this into a union of the two above. Add
	comments.
	(struct maps_info): New struct.
	(struct line_maps)<info_ordinary, info_macro>: Two new
	fields. These now carry the map information that was previously
	scattered in struct line_maps.
	(MAP_START_LOCATION, ORDINARY_MAP_FILE_NAME)
	(ORDINARY_MAP_STARTING_LINE_NUMBER)
	(ORDINARY_MAP_INCLUDER_FILE_INDEX)
	(ORDINARY_MAP_IN_SYSTEM_HEADER_P)
	(ORDINARY_MAP_NUMBER_OF_COLUMN_BITS, MACRO_MAP_MACRO)
	(MACRO_MAP_NUM_MACRO_TOKENS MACRO_MAP_LOCATIONS)
	(MACRO_MAP_EXPANSION_POINT_LOCATION, LOCATION_POSSIBLY_IN_MAP_P)
	(LOCATION_POSSIBLY_IN_MACRO_MAP_P, LINEMAPS_MAP_INFO)
	(LINEMAPS_MAPS, LINEMAPS_ALLOCATE, LINEMAPS_USED, LINEMAPS_CACHE)
	(LINEMAPS_HIGHEST_LOCATION, LINEMAPS_HIGHEST_LINE)
	(LINEMAPS_LAST_MAP, LINEMAPS_LAST_ALLOCATED_MAP)
	(LINEMAPS_ORDINARY_MAPS, LINEMAPS_ORDINARY_ALLOCATED)
	(LINEMAPS_ORDINARY_USED, LINEMAPS_ORDINARY_CACHE)
	(LINEMAPS_ORDINARY_HIGHEST_LOCATION)
	(LINEMAPS_ORDINARY_HIGHEST_LINE, LINEMAPS_LAST_ORDINARY_MAP)
	(LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP, LINEMAPS_MACRO_MAPS)
	(LINEMAPS_MACRO_ALLOCATED, LINEMAPS_MACRO_USED)
	(LINEMAPS_MACRO_CACHE, LINEMAPS_MACRO_HIGHEST_LOCATION)
	(LINEMAPS_MACRO_HIGHEST_LINE, LINEMAPS_LAST_MACRO_MAP)
	(LINEMAPS_LAST_ALLOCATED_MACRO_MAP, LINEMAPS_MAP_AT)
	(LINEMAPS_ORDINARY_MAP_AT, LINEMAPS_MACRO_MAP_AT) : New accessors
	for ordinary and macro map information.
	(linemap_init, linemap_free, linemap_add, linemap_lookup): Remove
	useless extern. Move comment to the function definition.
	(linemap_check_files_exited, linemap_line_start)
	(linemap_position_for_column): Remove useless extern.
	(linemap_position_for_line_and_column)
	(linemap_tracks_macro_expansion_locs_p, linemap_enter_macro)
	(linemap_add_macro_token, linemap_check_ordinary)
	(linemap_macro_expansion_map_p, linemap_macro_loc_to_exp_point)
	(linemap_macro_loc_to_def_point)
	(linemap_macro_map_loc_to_def_point)
	(linemap_macro_map_loc_to_exp_point, linemap_map_get_index)
	(linemap_get_source_line, linemap_get_source_column)
	(linemap_map_get_macro_name, linemap_get_file_path)
	(linemap_location_in_system_header_p)
	(linemap_location_from_macro_expansion_p): Declare new functions.
	(SOURCE_LINE, SOURCE_COLUMN, LAST_SOURCE_LINE_LOCATION)
	(LINEMAP_FILE, LINEMAP_LINE, LINEMAP_SYSP): Assert that this
	accessors act on ordinary maps only.
	(INCLUDED_FROM): Return NULL for main files; use the new
	accessors.
	(LINEMAP_POSITION_FOR_COLUMN): Use the new accessors.
	(struct expanded_location): Move here from gcc/input.h
	(linemap_expand_location_full, linemap_expand_location): Declare
	new functions.
	* line-map.c: Include cpp-id-data.h
	(linemap_assert): New macro.
	(new_linemap, create_and_add_line_map_internal): Define new static
	functions. Extracted from ...
	(linemap_add): ... here.
	(linemap_tracks_macro_expansion_locs_p, linemap_enter_macro)
	(linemap_add_macro_token, linemap_macro_expansion_map_p)
	(linemap_check_ordinary, linemap_macro_map_loc_to_exp_point)
	(linemap_macro_map_loc_to_def_point)
	(linemap_macro_loc_to_exp_point, linemap_map_get_index)
	(linemap_macro_loc_to_def_point, linemap_get_source_line)
	(linemap_get_source_column, linemap_get_file_path)
	(linemap_map_get_macro_name, linemap_location_in_system_header_p)
	(linemap_location_originated_from_system_header_p)
	(linemap_location_from_macro_expansion_p)
	(linemap_tracks_macro_expansion_locs_p)
	(linemap_expand_location_full)
	(linemap_tracks_macro_expansion_locs_p): Define new public
	functions.
	(linemap_init): Initialize ordinary and macro maps information in
	the map set.
	(linemap_check_files_exited): Use the new accessors.
	(linemap_free): Adjust to free what has been allocated. Use the
	accessors.
	(linemap_line_start): Assert this uses an ordinary map. Adjust to
	use the new ordinary map accessors and data structures. Use the
	new MAX_SOURCE_LOCATION constant.
	(linemap_position_for_column): Assert the ordinary maps of the map
	set are really ordinary. Use ordinary map accessors.
	(linemap_lookup): Keep the same logic but generalize to allow
	lookup of both ordinary and macro maps. Do not crash when called
	with an empty line table.
	* directives-only.c (_cpp_preprocess_dir_only): Adjust to use the
	new API of line-map.h.
	* directives.c (start_directive, do_line, do_linemarker)
	(do_linemarker): Likewise.
	* files.c (_cpp_find_file, _cpp_stack_include, open_file_failed)
	(make_cpp_dir, cpp_make_system_header): Likewise.
	* init.c (cpp_read_main_file): Likewise.
	* internal.h (CPP_INCREMENT_LINE): Likewise.
	* lex.c (_cpp_process_line_notes, _cpp_skip_block_comment)
	(skip_line_comment, skip_whitespace, lex_raw_string)
	(_cpp_lex_direct): Likewise.
	* macro.c (_cpp_builtin_macro_text): Likewise.
	(_cpp_aligned_alloc): Initialize the new name member of the macro.
	* traditional.c (copy_comment, _cpp_scan_out_logical_line):
	Likewise.
	* errors.c (cpp_diagnostic): Adjust to new linemap API.

gcc/
	* input.h (struct expanded_location): Move to libcpp/line-map.h.
	(LOCATION_COLUMN): New accessor
	(in_system_header_at): Use linemap_location_in_system_header_p.
	* diagnostic.c (diagnostic_report_current_module): Adjust to avoid
	touching the internals of struct line_map. Use the public API.
	instead.
	* input.c (expand_location): Fix the logic. Adjust to expand to
	the tokens spelling location when macro location tracking is on.

gcc/c-family

	* c-ppoutput.c (scan_translation_unit, maybe_print_line)
	(print_line, cb_define): Adjust to avoid touching the internals
	of struct line_map. Use the public API instead.
	* c-pch.c (c_common_read_pch): Adjust to new map API.

gcc/java/

	* jcf-parse.c (set_source_filename): Adjust to the new map API.

gcc/ada/

	* gcc-interface/trans.c (gigi, Sloc_to_locus): Adjust to use the
	new public ordinary map interface.

gcc/fortran/

	* cpp.c (print_line, cb_define): Adjust to avoid using internals
	of struct line_map. Use the public API instead.
---
 gcc/ada/gcc-interface/trans.c |   10 +-
 gcc/c-family/c-lex.c          |    6 +-
 gcc/c-family/c-pch.c          |    2 +-
 gcc/c-family/c-ppoutput.c     |   35 +-
 gcc/diagnostic.c              |    6 +-
 gcc/fortran/cpp.c             |   22 +-
 gcc/input.c                   |   40 ++-
 gcc/input.h                   |   20 +-
 gcc/java/jcf-parse.c          |    2 +-
 libcpp/directives-only.c      |    7 +-
 libcpp/directives.c           |   19 +-
 libcpp/errors.c               |    2 +-
 libcpp/files.c                |   24 +-
 libcpp/include/cpp-id-data.h  |    6 +
 libcpp/include/line-map.h     |  626 +++++++++++++++++++++++++-----
 libcpp/init.c                 |    2 +-
 libcpp/internal.h             |    5 +-
 libcpp/lex.c                  |   37 ++-
 libcpp/line-map.c             |  866 ++++++++++++++++++++++++++++++++++++-----
 libcpp/macro.c                |   19 +-
 libcpp/traditional.c          |    7 +-
 21 files changed, 1460 insertions(+), 303 deletions(-)

diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index b658620..c71c99a 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -268,7 +268,7 @@  gigi (Node_Id gnat_root, int max_gnat_node, int number_name ATTRIBUTE_UNUSED,
 	     (Get_Name_String (file_info_ptr[i].File_Name))));
 
       /* We rely on the order isomorphism between files and line maps.  */
-      gcc_assert ((int) line_table->used == i);
+      gcc_assert ((int) LINEMAPS_ORDINARY_USED (line_table) == i);
 
       /* We create the line map for a source file at once, with a fixed number
 	 of columns chosen to avoid jumping over the next power of 2.  */
@@ -7683,12 +7683,10 @@  Sloc_to_locus (Source_Ptr Sloc, location_t *locus)
       Source_File_Index file = Get_Source_File_Index (Sloc);
       Logical_Line_Number line = Get_Logical_Line_Number (Sloc);
       Column_Number column = Get_Column_Number (Sloc);
-      struct line_map *map = &line_table->maps[file - 1];
+      struct line_map *map = LINEMAPS_ORDINARY_MAP_AT (line_table, file - 1);
 
-      /* Translate the location according to the line-map.h formula.  */
-      *locus = map->start_location
-		+ ((line - map->to_line) << map->column_bits)
-		+ (column & ((1 << map->column_bits) - 1));
+      /* Translate the location.  */
+      *locus = linemap_position_for_line_and_column (map, line, column);
     }
 
   ref_filename
diff --git a/gcc/c-family/c-lex.c b/gcc/c-family/c-lex.c
index 778e424..085ecd4 100644
--- a/gcc/c-family/c-lex.c
+++ b/gcc/c-family/c-lex.c
@@ -207,7 +207,7 @@  fe_file_change (const struct line_map *new_map)
 	    line = SOURCE_LINE (new_map - 1, included_at);
 
 	  input_location = new_map->start_location;
-	  (*debug_hooks->start_source_file) (line, new_map->to_file);
+	  (*debug_hooks->start_source_file) (line, LINEMAP_FILE (new_map));
 #ifndef NO_IMPLICIT_EXTERN_C
 	  if (c_header_level)
 	    ++c_header_level;
@@ -231,10 +231,10 @@  fe_file_change (const struct line_map *new_map)
 #endif
       input_location = new_map->start_location;
 
-      (*debug_hooks->end_source_file) (new_map->to_line);
+      (*debug_hooks->end_source_file) (LINEMAP_LINE (new_map));
     }
 
-  update_header_times (new_map->to_file);
+  update_header_times (LINEMAP_FILE (new_map));
   input_location = new_map->start_location;
 }
 
diff --git a/gcc/c-family/c-pch.c b/gcc/c-family/c-pch.c
index b429d9d..9d4f799 100644
--- a/gcc/c-family/c-pch.c
+++ b/gcc/c-family/c-pch.c
@@ -423,7 +423,7 @@  c_common_read_pch (cpp_reader *pfile, const char *name,
     }
 
   /* Save the location and then restore it after reading the PCH.  */
-  saved_loc = expand_location (line_table->highest_line);
+  saved_loc = expand_location (LINEMAPS_ORDINARY_HIGHEST_LINE (line_table));
   saved_trace_includes = line_table->trace_includes;
 
   timevar_push (TV_PCH_CPP_RESTORE);
diff --git a/gcc/c-family/c-ppoutput.c b/gcc/c-family/c-ppoutput.c
index 1700fae..0def8fa 100644
--- a/gcc/c-family/c-ppoutput.c
+++ b/gcc/c-family/c-ppoutput.c
@@ -188,9 +188,7 @@  scan_translation_unit (cpp_reader *pfile)
       /* Subtle logic to output a space if and only if necessary.  */
       if (avoid_paste)
 	{
-	  const struct line_map *map
-	    = linemap_lookup (line_table, loc);
-	  int src_line = SOURCE_LINE (map, loc);
+	  int src_line = LOCATION_LINE (loc);
 
 	  if (print.source == NULL)
 	    print.source = token;
@@ -210,9 +208,7 @@  scan_translation_unit (cpp_reader *pfile)
 	}
       else if (token->flags & PREV_WHITE)
 	{
-	  const struct line_map *map
-	    = linemap_lookup (line_table, loc);
-	  int src_line = SOURCE_LINE (map, loc);
+	  int src_line = LOCATION_LINE (loc);
 
 	  if (src_line != print.src_line
 	      && do_line_adjustments
@@ -302,8 +298,7 @@  scan_translation_unit_trad (cpp_reader *pfile)
 static void
 maybe_print_line (source_location src_loc)
 {
-  const struct line_map *map = linemap_lookup (line_table, src_loc);
-  int src_line = SOURCE_LINE (map, src_loc);
+  int src_line = LOCATION_LINE (src_loc);
   /* End the previous line of text.  */
   if (print.printed)
     {
@@ -336,27 +331,29 @@  print_line (source_location src_loc, const char *special_flags)
 
   if (!flag_no_line_commands)
     {
-      const struct line_map *map = linemap_lookup (line_table, src_loc);
-
-      size_t to_file_len = strlen (map->to_file);
+      const char *file_path = LOCATION_FILE (src_loc);
+      int sysp;
+      size_t to_file_len = strlen (file_path);
       unsigned char *to_file_quoted =
          (unsigned char *) alloca (to_file_len * 4 + 1);
       unsigned char *p;
 
-      print.src_line = SOURCE_LINE (map, src_loc);
+      print.src_line = LOCATION_LINE (src_loc);
 
       /* cpp_quote_string does not nul-terminate, so we have to do it
 	 ourselves.  */
       p = cpp_quote_string (to_file_quoted,
-			    (const unsigned char *) map->to_file, to_file_len);
+			    (const unsigned char *) file_path,
+			    to_file_len);
       *p = '\0';
       fprintf (print.outf, "# %u \"%s\"%s",
 	       print.src_line == 0 ? 1 : print.src_line,
 	       to_file_quoted, special_flags);
 
-      if (map->sysp == 2)
+      sysp = in_system_header_at (src_loc);
+      if (sysp == 2)
 	fputs (" 3 4", print.outf);
-      else if (map->sysp == 1)
+      else if (sysp == 1)
 	fputs (" 3", print.outf);
 
       putc ('\n', print.outf);
@@ -385,8 +382,7 @@  do_line_change (cpp_reader *pfile, const cpp_token *token,
      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);
-      int spaces = SOURCE_COLUMN (map, src_loc) - 2;
+      int spaces = LOCATION_COLUMN (src_loc) - 2;
       print.printed = 1;
 
       while (-- spaces >= 0)
@@ -415,6 +411,8 @@  cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 static void
 cb_define (cpp_reader *pfile, source_location line, cpp_hashnode *node)
 {
+  const struct line_map *map;
+
   maybe_print_line (line);
   fputs ("#define ", print.outf);
 
@@ -426,7 +424,8 @@  cb_define (cpp_reader *pfile, source_location line, cpp_hashnode *node)
     fputs ((const char *) NODE_NAME (node), print.outf);
 
   putc ('\n', print.outf);
-  if (linemap_lookup (line_table, line)->to_line != 0)
+  linemap_macro_loc_to_exp_point (line_table, line, &map);
+  if (LINEMAP_LINE (map) != 0)
     print.src_line++;
 }
 
diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c
index d297cdd..9df540b 100644
--- a/gcc/diagnostic.c
+++ b/gcc/diagnostic.c
@@ -278,18 +278,18 @@  diagnostic_report_current_module (diagnostic_context *context)
 	  if (context->show_column)
 	    pp_verbatim (context->printer,
 			 "In file included from %s:%d:%d",
-			 map->to_file,
+			 LINEMAP_FILE (map),
 			 LAST_SOURCE_LINE (map), LAST_SOURCE_COLUMN (map));
 	  else
 	    pp_verbatim (context->printer,
 			 "In file included from %s:%d",
-			 map->to_file, LAST_SOURCE_LINE (map));
+			 LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
 	  while (! MAIN_FILE_P (map))
 	    {
 	      map = INCLUDED_FROM (line_table, map);
 	      pp_verbatim (context->printer,
 			   ",\n                 from %s:%d",
-			   map->to_file, LAST_SOURCE_LINE (map));
+			   LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
 	    }
 	  pp_verbatim (context->printer, ":");
 	  pp_newline (context->printer);
diff --git a/gcc/fortran/cpp.c b/gcc/fortran/cpp.c
index 4c1307c..c1b4d44 100644
--- a/gcc/fortran/cpp.c
+++ b/gcc/fortran/cpp.c
@@ -810,27 +810,29 @@  print_line (source_location src_loc, const char *special_flags)
 
   if (!gfc_cpp_option.no_line_commands)
     {
-      const struct line_map *map = linemap_lookup (line_table, src_loc);
-
-      size_t to_file_len = strlen (map->to_file);
-      unsigned char *to_file_quoted =
-         (unsigned char *) alloca (to_file_len * 4 + 1);
+      expanded_location loc;
+      size_t to_file_len;
+      unsigned char *to_file_quoted;
       unsigned char *p;
 
-      print.src_line = SOURCE_LINE (map, src_loc);
+      loc = expand_location (src_loc);
+      to_file_len = strlen (loc.file);
+      to_file_quoted = (unsigned char *) alloca (to_file_len * 4 + 1);
+
+      print.src_line = loc.line;
 
       /* cpp_quote_string does not nul-terminate, so we have to do it
 	 ourselves.  */
       p = cpp_quote_string (to_file_quoted,
-			    (const unsigned char *) map->to_file, to_file_len);
+			    (const unsigned char *) loc.file, to_file_len);
       *p = '\0';
       fprintf (print.outf, "# %u \"%s\"%s",
 	       print.src_line == 0 ? 1 : print.src_line,
 	       to_file_quoted, special_flags);
 
-      if (map->sysp == 2)
+      if (loc.sysp == 2)
 	fputs (" 3 4", print.outf);
-      else if (map->sysp == 1)
+      else if (loc.sysp == 1)
 	fputs (" 3", print.outf);
 
       putc ('\n', print.outf);
@@ -927,7 +929,7 @@  cb_define (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
     fputs ((const char *) NODE_NAME (node), print.outf);
 
   putc ('\n', print.outf);
-  if (linemap_lookup (line_table, line)->to_line != 0)
+  if (LOCATION_LINE (line) != 0)
     print.src_line++;
 }
 
diff --git a/gcc/input.c b/gcc/input.c
index e5e051f..6dbc253 100644
--- a/gcc/input.c
+++ b/gcc/input.c
@@ -35,19 +35,43 @@  expand_location (source_location loc)
 {
   expanded_location xloc;
   if (loc <= BUILTINS_LOCATION)
-    {
-      xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>");
+    {      
+      /* If LOC is UNKNOWN_LOCATION and there was a map allocated for
+	 it then XLOC.FILE should be the file path of the map,
+	 i.e. the file path of the main file being compiled.
+	 Otherwise [if we are being called before any line map has
+	 been allocated, e.g. during parsing of commande line
+	 options] if no line map has been allocated yet, then
+	 XLOC.FILE should just be NULL.  */
+      if (loc == UNKNOWN_LOCATION)
+	{
+	  const struct line_map *map =
+	    linemap_lookup (line_table, UNKNOWN_LOCATION);
+	  xloc.file = map != NULL ? LINEMAP_FILE (map) : NULL;
+	}
+      else
+	xloc.file = _("<built-in>");
       xloc.line = 0;
       xloc.column = 0;
       xloc.sysp = 0;
     }
   else
     {
-      const struct line_map *map = linemap_lookup (line_table, loc);
-      xloc.file = map->to_file;
-      xloc.line = SOURCE_LINE (map, loc);
-      xloc.column = SOURCE_COLUMN (map, loc);
-      xloc.sysp = map->sysp != 0;
-    };
+      bool expand_to_expansion_point_p =
+	!linemap_tracks_macro_expansion_locs_p (line_table);
+
+    /* If LOC is the location of a token resulting from macro
+       expansion, either expand to the location of the macro expansion
+       point if we don't support tracking token locations accross
+       macro expansion, or expand to the actual spelling location of
+       the token where the error is if we do support tracking
+       locations accross macro expansion.  */
+      xloc =
+	linemap_expand_location_full (line_table, loc,
+				      (expand_to_expansion_point_p)
+				      ? LRK_MACRO_EXPANSION_POINT
+				      : LRK_SPELLING_LOCATION,
+				      NULL);
+    }
   return xloc;
 }
diff --git a/gcc/input.h b/gcc/input.h
index 5929064..835c95a 100644
--- a/gcc/input.h
+++ b/gcc/input.h
@@ -37,20 +37,6 @@  extern GTY(()) struct line_maps *line_table;
 extern char builtins_location_check[(BUILTINS_LOCATION
 				     < RESERVED_LOCATION_COUNT) ? 1 : -1];
 
-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;
-
 extern expanded_location expand_location (source_location);
 
 /* Historically GCC used location_t, while cpp used source_location.
@@ -61,10 +47,12 @@  extern location_t input_location;
 
 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
+#define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 
 #define input_line LOCATION_LINE (input_location)
 #define input_filename LOCATION_FILE (input_location)
-#define in_system_header_at(LOC) ((expand_location (LOC)).sysp != 0)
-#define in_system_header (in_system_header_at (input_location))
+#define in_system_header_at(LOC) \
+  ((linemap_location_in_system_header_p (line_table, LOC)))
+#define in_system_header  (in_system_header_at (input_location))
 
 #endif
diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index 9166f31..07a0bb3 100644
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -356,7 +356,7 @@  set_source_filename (JCF *jcf, int index)
     }
       
   sfname = find_sourcefile (sfname);
-  line_table->maps[line_table->used-1].to_file = sfname;
+  ORDINARY_MAP_FILE_NAME (LINEMAPS_LAST_ORDINARY_MAP (line_table)) = sfname;
   if (current_class == main_class) main_input_filename = sfname;
 }
 
diff --git a/libcpp/directives-only.c b/libcpp/directives-only.c
index e19f806..e478fc3 100644
--- a/libcpp/directives-only.c
+++ b/libcpp/directives-only.c
@@ -54,7 +54,7 @@  _cpp_preprocess_dir_only (cpp_reader *pfile,
   buffer->need_line = false;
 
   /* This isn't really needed.  It prevents a compiler warning, though. */
-  loc = pfile->line_table->highest_line;
+  loc = LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 
   /* Scan initialization. */
   next_line = cur = base = buffer->cur;
@@ -107,13 +107,14 @@  _cpp_preprocess_dir_only (cpp_reader *pfile,
 	    /* Sanitize the line settings.  Duplicate #include's can mess
 	       things up. */
 	    line_table = pfile->line_table;
-	    line_table->highest_location = line_table->highest_line;
+	    LINEMAPS_ORDINARY_HIGHEST_LOCATION (line_table) =
+	      LINEMAPS_ORDINARY_HIGHEST_LINE (line_table);
 
 	    /* The if block prevents us from outputing line information when
 	       the file ends with a directive and no newline.  Note that we
 	       must use pfile->buffer, not buffer. */
 	    if (pfile->buffer->next_line < pfile->buffer->rlimit)
-	      cb->maybe_print_line (pfile->line_table->highest_line);
+	      cb->maybe_print_line (LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table));
 
 	    goto restart;
 	  }
diff --git a/libcpp/directives.c b/libcpp/directives.c
index 6462605..4c273e0 100644
--- a/libcpp/directives.c
+++ b/libcpp/directives.c
@@ -274,7 +274,8 @@  start_directive (cpp_reader *pfile)
   pfile->directive_result.type = CPP_PADDING;
 
   /* Some handlers need the position of the # for diagnostics.  */
-  pfile->directive_line = pfile->line_table->highest_line;
+  pfile->directive_line =
+    LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 }
 
 /* Called when leaving a directive, _Pragma or command-line directive.  */
@@ -883,14 +884,14 @@  static void
 do_line (cpp_reader *pfile)
 {
   const struct line_maps *line_table = pfile->line_table;
-  const struct line_map *map = &line_table->maps[line_table->used - 1];
+  const struct line_map *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.  */
 
-  unsigned char map_sysp = map->sysp;
+  unsigned char map_sysp = map->d.ordinary.sysp;
   const cpp_token *token;
-  const char *new_file = map->to_file;
+  const char *new_file = map->d.ordinary.to_file;
   linenum_type new_lineno;
 
   /* C99 raised the minimum limit on #line numbers.  */
@@ -945,11 +946,11 @@  static void
 do_linemarker (cpp_reader *pfile)
 {
   const struct line_maps *line_table = pfile->line_table;
-  const struct line_map *map = &line_table->maps[line_table->used - 1];
+  const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
   const cpp_token *token;
-  const char *new_file = map->to_file;
+  const char *new_file = map->d.ordinary.to_file;
   linenum_type new_lineno;
-  unsigned int new_sysp = map->sysp;
+  unsigned int new_sysp = map->d.ordinary.sysp;
   enum lc_reason reason = LC_RENAME_VERBATIM;
   int flag;
   bool wrapped;
@@ -1020,7 +1021,7 @@  do_linemarker (cpp_reader *pfile)
      *following* the #line directive.  A separate source_location for this
      location makes no sense (until we do the LC_LEAVE), and
      complicates LAST_SOURCE_LINE_LOCATION.  */
-  pfile->line_table->highest_location--;
+  LINEMAPS_ORDINARY_HIGHEST_LOCATION (pfile->line_table)--;
 
   _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
 }
@@ -1037,7 +1038,7 @@  _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
   const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
 					    to_file, file_line);
   if (map != NULL)
-    linemap_line_start (pfile->line_table, map->to_line, 127);
+    linemap_line_start (pfile->line_table, map->d.ordinary.to_line, 127);
 
   if (pfile->cb.file_change)
     pfile->cb.file_change (pfile, map);
diff --git a/libcpp/errors.c b/libcpp/errors.c
index b7783f5..821e4ed 100644
--- a/libcpp/errors.c
+++ b/libcpp/errors.c
@@ -43,7 +43,7 @@  cpp_diagnostic (cpp_reader * pfile, int level, int reason,
       if (pfile->state.in_directive)
 	src_loc = pfile->directive_line;
       else
-	src_loc = pfile->line_table->highest_line;
+	src_loc = LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
     }
   /* We don't want to refer to a token before the beginning of the
      current run -- that is invalid.  */
diff --git a/libcpp/files.c b/libcpp/files.c
index be39db9..363b71f 100644
--- a/libcpp/files.c
+++ b/libcpp/files.c
@@ -542,7 +542,7 @@  _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool f
   entry = new_file_hash_entry (pfile);
   entry->next = *hash_slot;
   entry->start_dir = start_dir;
-  entry->location = pfile->line_table->highest_location;
+  entry->location = LINEMAPS_ORDINARY_HIGHEST_LOCATION (pfile->line_table);
   entry->u.file = file;
   *hash_slot = entry;
 
@@ -555,7 +555,7 @@  _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool f
       entry = new_file_hash_entry (pfile);
       entry->next = *hash_slot;
       entry->start_dir = pfile->bracket_include;
-      entry->location = pfile->line_table->highest_location;
+      entry->location = LINEMAPS_ORDINARY_HIGHEST_LOCATION (pfile->line_table);
       entry->u.file = file;
       *hash_slot = entry;
     }
@@ -566,7 +566,8 @@  _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool f
       entry = new_file_hash_entry (pfile);
       entry->next = *hash_slot;
       entry->start_dir = pfile->quote_include;
-      entry->location = pfile->line_table->highest_location;
+      entry->location =
+	LINEMAPS_ORDINARY_HIGHEST_LOCATION (pfile->line_table);
       entry->u.file = file;
       *hash_slot = entry;
     }
@@ -927,7 +928,7 @@  _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
      linemap_add is not called) or we were included from the
      command-line.  */
   if (file->pchname == NULL && file->err_no == 0 && type != IT_CMDLINE)
-    pfile->line_table->highest_location--;
+    LINEMAPS_ORDINARY_HIGHEST_LOCATION (pfile->line_table)--;
 
   return _cpp_stack_file (pfile, file, type == IT_IMPORT);
 }
@@ -936,7 +937,8 @@  _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
 static void
 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
 {
-  int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
+  int sysp = (LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table) > 1)
+    && (pfile->buffer ? pfile->buffer->sysp : 0);
   bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
 
   errno = file->err_no;
@@ -1049,7 +1051,7 @@  make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
   entry = new_file_hash_entry (pfile);
   entry->next = *hash_slot;
   entry->start_dir = NULL;
-  entry->location = pfile->line_table->highest_location;
+  entry->location = LINEMAPS_ORDINARY_HIGHEST_LOCATION (pfile->line_table);
   entry->u.dir = dir;
   *hash_slot = entry;
 
@@ -1221,14 +1223,16 @@  cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
 {
   int flags = 0;
   const struct line_maps *line_table = pfile->line_table;
-  const struct line_map *map = &line_table->maps[line_table->used-1];
-
+  const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
   /* 1 = system header, 2 = system header to be treated as C.  */
   if (syshdr)
     flags = 1 + (externc != 0);
   pfile->buffer->sysp = flags;
-  _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
-		       SOURCE_LINE (map, pfile->line_table->highest_line), flags);
+  _cpp_do_file_change (pfile, LC_RENAME, map->d.ordinary.to_file,
+		       SOURCE_LINE (map,
+				    LINEMAPS_ORDINARY_HIGHEST_LINE
+				    (pfile->line_table)),
+		       flags);
 }
 
 /* Allow the client to change the current file.  Used by the front end
diff --git a/libcpp/include/cpp-id-data.h b/libcpp/include/cpp-id-data.h
index a57edad..8260fd0 100644
--- a/libcpp/include/cpp-id-data.h
+++ b/libcpp/include/cpp-id-data.h
@@ -34,6 +34,12 @@  struct GTY(()) answer {
 /* Each macro definition is recorded in a cpp_macro structure.
    Variadic macros cannot occur with traditional cpp.  */
 struct GTY(()) cpp_macro {
+  /* Name of this macro.  Used only for error reporting.  */
+  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")))
+    name;
+
   /* Parameters, if any.  */
   cpp_hashnode ** GTY ((nested_ptr (union tree_node,
 		"%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h
index 3f52d75..0011f38 100644
--- a/libcpp/include/line-map.h
+++ b/libcpp/include/line-map.h
@@ -27,13 +27,23 @@  along with this program; see the file COPYING3.  If not see
 #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
+  /* stringize */
+  /* paste */
+};
 
 /* The type of line numbers.  */
 typedef unsigned int linenum_type;
@@ -44,42 +54,235 @@  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
+/* An ordinary line map encodes physical source locations. Those
+   physicall 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 {
+   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
+{
   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.  */
+
+  /* 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 macro map.  */
+#define MAX_SOURCE_LOCATION 0xF0000000
+
+struct GTY(()) cpp_macro;
+
+/* A macro line map encodes locations 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_macro *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 we are at the expansion point of MACRO.  Each xI is the
+     location of the Ith token of the replacement-list. Now it gets
+     confusing. the xI is the location of the Ith token of the
+     replacement-list at the macro *definition* point. Not at the
+     macro replacement point. Okay, let's try to explain this below.
+
+     Imagine this:
+
+        #define OPERATION(OP0, OPERATOR, OP1) \
+                OP0 OPERATOR OP1 <-- #0
+
+	#define PLUS(A, B) OPERATION (A, +, B)  <--- #1
+
+	int a = PLUS (1,2); <--- #2
+     
+     In #2, there is a macro map for the expansion of PLUS. PLUS is
+     expanded into the replacement-list made of the tokens:
+     
+        OPERATION, (, A, +, B, )
+
+     and then further expanded into the tokens:
+
+        1, +, 2.
+
+     Let's consider the case of token "+" here. That will help us
+     understand what the xI we were talking about earlier means.
+
+     The token '+' has two locations, so to speak. One in the context
+     of the macro *expansion* of PLUS in #2 and one in the context of
+     the macro *definition* of PLUS in #1. These two locations are
+     encoded in the the latter context, somehow in the xI we are
+     talking about.
+
+     xI is roughly the index of the token inside the replacement-list
+     at the expansion point. So for '+', it's index would then be 1
+     [The index of token '1' would be 0 and the index of token 2 would
+     be 1]. So if '+' is our current xI, it is actualy an x1.
+
+     The value of x1 is the location of the token '+' inside the
+     replacement-list of PLUS at the definition point of PLUS. It is
+     its spelling location in #1.
+
+     So x0 would have described the token '1', x1 describes the token
+     '+' and x2 describes the token '2'.
+
+     Now what's the y1 then? Remember, we said macro_locations is an
+     array of pairs (xI,yI). We now know what the xI is, now let's
+     look at the yI.
+
+     Let's look at the token '+' again. We said it has two locations
+     somehow. Actually it has 3. Kind of. As '+' is an argument passed
+     to the macro OPERATION [at the definition point of the macro
+     PLUS], it would be nice to record the source location of the
+     *parameter* of OPERATION that is replaced by the argument '+'.
+     In other words, we want to record the location of the token
+     "OPERATOR" in the replacement-list of OPERATION, at the
+     /definition/ point of OPERATION in #0. And that is y1.
+
+     So when (xI,yI) describes a token that is passed as an argument
+     to a macro M, the yI is the location of the macro parameter that
+     the argument replaces, at the definition point of M. If (xI,yI)
+     does not describe a token that is passed as an argument to a
+     macro, xI == yI.
+   */
+  source_location * GTY((length ("2 * %h.n_tokens"))) macro_locations;
+
+  /* This is the location of the expansion point of the current macro
+     map.  That expansion point location is hold 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 {
+    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) (MAP)->d.ordinary.to_file
+
+#define ORDINARY_MAP_STARTING_LINE_NUMBER(MAP) (MAP)->d.ordinary.to_line
+
+#define ORDINARY_MAP_INCLUDER_FILE_INDEX(MAP) (MAP)->d.ordinary.included_from
+
+#define ORDINARY_MAP_IN_SYSTEM_HEADER_P(MAP) (MAP)->d.ordinary.sysp
+
+#define ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(MAP) (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 allocated size of 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;
 
-  /* 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;
+  /* Highest source_location "given out".  */
+  source_location highest_location;
+
+  /* Start of line of highest source_location "given out".  */
+  source_location highest_line;
+};
+
+/* A set of chronological line_map structures.  */
+struct GTY(()) line_maps {
+  
+  struct maps_info info_ordinary;
+
+  struct maps_info info_macro;
 
   /* Depth of the include stack, including the current file.  */
   unsigned int depth;
@@ -87,12 +290,6 @@  struct GTY(()) line_maps {
   /* If true, prints an include trace a la -H.  */
   bool trace_includes;
 
-  /* Highest source_location "given out".  */
-  source_location highest_location;
-
-  /* Start of line of highest source_location "given out".  */
-  source_location highest_line;
-
   /* The maximum column number we can quickly allocate.  Higher numbers
      may require allocating a new line_map.  */
   unsigned int max_column_hint;
@@ -102,44 +299,232 @@  struct GTY(()) line_maps {
   line_map_realloc reallocator;
 };
 
-/* Initialize a line map set.  */
-extern void linemap_init (struct line_maps *);
+/* Return TRUE if LOC is possibly encoded in MAP, FALSE otherwise.
+   MACRO_MAP_P shall be TRUE if MAP is to be considered as a macro
+   map, false otherwise.  */
+#define LOCATION_POSSIBLY_IN_MAP_P(LOC, MAP, MACRO_MAP_P)		\
+  (((MACRO_MAP_P))							\
+   ? (LOC) <= (MAP)->start_location					\
+   : (LOC) >= (MAP)->start_location)
+
+/* Return TRUE if LOC is possibly encoded in the macro map MAP, FALSE
+   otherwise.  */
+#define LOCATION_POSSIBLY_IN_MACRO_MAP_P(LOC, MAP) \
+  LOCATION_POSSIBLY_IN_MAP_P ((LOC), (MAP), true)
+
+/* 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
+
+/* Returns the highest location that was encoded into the line table
+   SET. MAP_KIND shall be TRUE if we are interested in locations of
+   tokens resulting from macro expansion, FALSE otherwise.  */
+#define LINEMAPS_HIGHEST_LOCATION(SET, MAP_KIND) \
+  (LINEMAPS_MAP_INFO (SET, MAP_KIND))->highest_location
+
+/* Returns the location of the begining of the highest line that was
+   encoded in into the line table SET.  MAP_KIND shall be TRUE if we
+   are interested in locations of tokens resulting from macro
+   expansion, FALSE otherwise.  */
+#define LINEMAPS_HIGHEST_LINE(SET, MAP_KIND) \
+  (LINEMAPS_MAP_INFO (SET, MAP_KIND))->highest_line
+
+/* 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)
+
+/* Return the highest location of an ordinary token encoded in the
+   line table SET.  */
+#define LINEMAPS_ORDINARY_HIGHEST_LOCATION(SET) \
+  LINEMAPS_HIGHEST_LOCATION(SET, false)
+
+/* Return the location of the beginning of the highest (containing
+   ordinary tokens) line encoded in the in the set.  */
+#define LINEMAPS_ORDINARY_HIGHEST_LINE(SET) \
+  LINEMAPS_HIGHEST_LINE(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 highest location [of a token resulting from macro
+   expansion] encoded in this line table.  */
+#define LINEMAPS_MACRO_HIGHEST_LOCATION(SET) \
+  LINEMAPS_HIGHEST_LOCATION(SET, true)
+
+/* Returns the location of the begining of the highest line
+   -- containing a token resulting from macro expansion --  encoded
+   in the line table SET.  */
+#define LINEMAPS_MACRO_HIGHEST_LINE(SET) \
+  LINEMAPS_HIGHEST_LINE(SET, true)
+
+/* 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)
+
+void linemap_init (struct line_maps *);
+
+void linemap_free (struct line_maps *);
+
+void linemap_check_files_exited (struct line_maps *);
+
+bool linemap_tracks_macro_expansion_locs_p (struct line_maps *);
+
+source_location linemap_line_start
+(struct line_maps *set, linenum_type to_line,  unsigned int max_column_hint);
 
-/* Free a line map set.  */
-extern void linemap_free (struct line_maps *);
+const struct line_map *linemap_add (struct line_maps *,
+				    enum lc_reason,
+				    unsigned int sysp,
+				    const char *to_file,
+				    linenum_type to_line);
 
-/* Check for and warn about line_maps entered but not exited.  */
+const struct line_map *linemap_enter_macro (struct line_maps *,
+					    struct cpp_macro*,
+					    source_location,
+					    unsigned int);
 
-extern void linemap_check_files_exited (struct line_maps *);
 
-/* Return a source_location for the start (i.e. column==0) of
-   (physical) line TO_LINE in the current source file (as in the
-   most recent linemap_add).   MAX_COLUMN_HINT is the highest column
-   number we expect to use in this line (but it does not change
-   the highest_location).  */
+source_location linemap_add_macro_token (const struct line_map *,
+					 unsigned int,
+					 source_location,
+					 source_location);
 
-extern source_location linemap_line_start
-(struct line_maps *set, linenum_type to_line,  unsigned int max_column_hint);
+const struct line_map *linemap_lookup (struct line_maps *, source_location);
+
+int linemap_check_ordinary (const struct line_map *);
+
+bool linemap_macro_expansion_map_p (const struct line_map *);
+
+source_location linemap_macro_loc_to_exp_point (struct line_maps *,
+						source_location,
+						const struct line_map **);
+
+source_location linemap_macro_loc_to_def_point (struct line_maps *,
+						source_location,
+						const struct line_map **,
+						bool);
+
+source_location linemap_macro_map_loc_to_def_point (const struct line_map*,
+						    source_location,
+						    bool);
+
+source_location linemap_macro_map_loc_to_exp_point (const struct line_map*,
+						    source_location);
 
-/* Add a mapping of logical source line to physical source file and
-   line number.
+int linemap_map_get_index (const struct line_maps *,
+			   const struct line_map*);
 
-   The text pointed to by TO_FILE must have a lifetime
-   at least as long as the final call to lookup_line ().  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.
+int linemap_get_source_line (struct line_maps *,
+			     source_location);
 
-   A call to this function can relocate the previous set of
-   maps, so any stored line_map pointers should not be used.  */
-extern const struct line_map *linemap_add
-  (struct line_maps *, enum lc_reason, unsigned int sysp,
-   const char *to_file, linenum_type to_line);
+int linemap_get_source_column (struct line_maps *,
+			       source_location);
 
-/* Given a logical line, returns the map from which the corresponding
-   (source file, line) pair can be deduced.  */
-extern const struct line_map *linemap_lookup
-  (struct line_maps *, source_location);
+const char* linemap_map_get_macro_name (const struct line_map*);
+
+const char* linemap_get_file_path (struct line_maps *,
+				   source_location);
+
+int linemap_location_in_system_header_p (struct line_maps *,
+					 source_location);
+
+bool linemap_location_from_macro_expansion_p (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
@@ -147,47 +532,112 @@  extern const struct line_map *linemap_lookup
 #define RESERVED_LOCATION_COUNT	2
 
 /* 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)
-
-#define SOURCE_COLUMN(MAP, LOC) \
-  (((LOC) - (MAP)->start_location) & ((1 << (MAP)->column_bits) - 1))
-
-/* Returns the last source line within a map.  This is the (last) line
-   of the #include, or other directive, that caused a map change.  */
+#define SOURCE_LINE(MAP, LOC)						\
+  (linemap_check_ordinary (MAP),					\
+    ((((LOC) - (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)				\
+  (linemap_check_ordinary (MAP),			\
+   (((LOC) - (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),				\
+   ((((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),					\
+   ((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)
+#define MAIN_FILE_P(MAP)			\
+  (linemap_check_ordinary (MAP),		\
+   ((MAP)->d.ordinary.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)
-    
-
-extern source_location
-linemap_position_for_column (struct line_maps *set, unsigned int to_column);
+#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 = LINEMAPS_ORDINARY_HIGHEST_LINE (set);	\
+	r = r + to_column;						\
+	if (r >= LINEMAPS_ORDINARY_HIGHEST_LOCATION (set))		\
+	  LINEMAPS_ORDINARY_HIGHEST_LOCATION (set) = r;			\
+	(LOC) = r;							\
+      }									\
+  } while (0)
+
+source_location linemap_position_for_column (struct line_maps *, unsigned int);
+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), (MAP)->d.ordinary.to_file)
+
+/* Return the line number this map started encoding location from.  */
+#define LINEMAP_LINE(MAP)					\
+  (linemap_check_ordinary (MAP), (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), (MAP)->d.ordinary.sysp)
+
+typedef struct GTY (())
+{
+  /* 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;
+
+enum location_resolution_kind
+{
+  LRK_MACRO_EXPANSION_POINT,
+  LRK_SPELLING_LOCATION,
+  LRK_MACRO_PARM_REPLACEMENT_POINT
+};
+
+expanded_location linemap_expand_location (struct line_maps *,
+					   source_location);
 
+expanded_location linemap_expand_location_full (struct line_maps *,
+						source_location,
+						enum location_resolution_kind,
+						const struct line_map**);
 #endif /* !LIBCPP_LINE_MAP_H  */
diff --git a/libcpp/init.c b/libcpp/init.c
index cfc16e8..8836143 100644
--- a/libcpp/init.c
+++ b/libcpp/init.c
@@ -574,7 +574,7 @@  cpp_read_main_file (cpp_reader *pfile, const char *fname)
   if (CPP_OPTION (pfile, preprocessed))
     {
       read_original_filename (pfile);
-      fname = pfile->line_table->maps[pfile->line_table->used-1].to_file;
+      fname = (LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table))->d.ordinary.to_file;
     }
   return fname;
 }
diff --git a/libcpp/internal.h b/libcpp/internal.h
index d2872c4..f02c878 100644
--- a/libcpp/internal.h
+++ b/libcpp/internal.h
@@ -67,8 +67,9 @@  struct cset_converter
 
 #define CPP_INCREMENT_LINE(PFILE, COLS_HINT) do { \
     const struct line_maps *line_table = PFILE->line_table; \
-    const struct line_map *map = &line_table->maps[line_table->used-1]; \
-    linenum_type line = SOURCE_LINE (map, line_table->highest_line); \
+    const struct line_map *map = \
+      LINEMAPS_LAST_ORDINARY_MAP (line_table); \
+    linenum_type line = SOURCE_LINE (map, LINEMAPS_ORDINARY_HIGHEST_LINE (line_table)); \
     linemap_line_start (PFILE->line_table, line + 1, COLS_HINT); \
   } while (0)
 
diff --git a/libcpp/lex.c b/libcpp/lex.c
index 5cd5686..bcf292c 100644
--- a/libcpp/lex.c
+++ b/libcpp/lex.c
@@ -830,12 +830,17 @@  _cpp_process_line_notes (cpp_reader *pfile, int in_comment)
       if (note->type == '\\' || note->type == ' ')
 	{
 	  if (note->type == ' ' && !in_comment)
-	    cpp_error_with_line (pfile, CPP_DL_WARNING, pfile->line_table->highest_line, col,
+	    cpp_error_with_line (pfile, CPP_DL_WARNING,
+				 LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table),
+				 col,
 				 "backslash and newline separated by space");
 
 	  if (buffer->next_line > buffer->rlimit)
 	    {
-	      cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->line_table->highest_line, col,
+	      cpp_error_with_line (pfile, CPP_DL_PEDWARN,
+				   LINEMAPS_ORDINARY_HIGHEST_LINE
+				   (pfile->line_table),
+				   col,
 				   "backslash-newline at end of file");
 	      /* Prevent "no newline at end of file" warning.  */
 	      buffer->next_line = buffer->rlimit;
@@ -851,7 +856,9 @@  _cpp_process_line_notes (cpp_reader *pfile, int in_comment)
 	    {
 	      if (CPP_OPTION (pfile, trigraphs))
 		cpp_warning_with_line (pfile, CPP_W_TRIGRAPHS,
-                                       pfile->line_table->highest_line, col,
+                                       LINEMAPS_ORDINARY_HIGHEST_LINE
+				       (pfile->line_table),
+				       col,
 				       "trigraph ??%c converted to %c",
 				       note->type,
 				       (int) _cpp_trigraph_map[note->type]);
@@ -859,7 +866,7 @@  _cpp_process_line_notes (cpp_reader *pfile, int in_comment)
 		{
 		  cpp_warning_with_line 
 		    (pfile, CPP_W_TRIGRAPHS,
-                     pfile->line_table->highest_line, col,
+                     LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table), col,
 		     "trigraph ??%c ignored, use -trigraphs to enable",
 		     note->type);
 		}
@@ -907,7 +914,8 @@  _cpp_skip_block_comment (cpp_reader *pfile)
 	    {
 	      buffer->cur = cur;
 	      cpp_warning_with_line (pfile, CPP_W_COMMENTS,
-				     pfile->line_table->highest_line,
+				     LINEMAPS_ORDINARY_HIGHEST_LINE
+				     (pfile->line_table),
 				     CPP_BUF_COL (buffer),
 				     "\"/*\" within comment");
 	    }
@@ -940,13 +948,14 @@  static int
 skip_line_comment (cpp_reader *pfile)
 {
   cpp_buffer *buffer = pfile->buffer;
-  source_location orig_line = pfile->line_table->highest_line;
+  source_location orig_line =
+    LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 
   while (*buffer->cur != '\n')
     buffer->cur++;
 
   _cpp_process_line_notes (pfile, true);
-  return orig_line != pfile->line_table->highest_line;
+  return orig_line != LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 }
 
 /* Skips whitespace, saving the next non-whitespace character.  */
@@ -965,7 +974,8 @@  skip_whitespace (cpp_reader *pfile, cppchar_t c)
       else if (c == '\0')
 	saw_NUL = true;
       else if (pfile->state.in_directive && CPP_PEDANTIC (pfile))
-	cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->line_table->highest_line,
+	cpp_error_with_line (pfile, CPP_DL_PEDWARN,
+			     LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table),
 			     CPP_BUF_COL (buffer),
 			     "%s in preprocessing directive",
 			     c == '\f' ? "form feed" : "vertical tab");
@@ -1461,7 +1471,8 @@  lex_raw_string (cpp_reader *pfile, cpp_token *token, const uchar *base,
 	      source_location src_loc = token->src_loc;
 	      token->type = CPP_EOF;
 	      /* Tell the compiler the line number of the EOF token.  */
-	      token->src_loc = pfile->line_table->highest_line;
+	      token->src_loc =
+		LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 	      token->flags = BOL;
 	      if (first_buff != NULL)
 		_cpp_release_buff (pfile, first_buff);
@@ -1952,7 +1963,8 @@  _cpp_lex_direct (cpp_reader *pfile)
 	  if (!pfile->state.in_directive)
 	    {
 	      /* Tell the compiler the line number of the EOF token.  */
-	      result->src_loc = pfile->line_table->highest_line;
+	      result->src_loc =
+		LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 	      result->flags = BOL;
 	    }
 	  return result;
@@ -1969,14 +1981,15 @@  _cpp_lex_direct (cpp_reader *pfile)
     }
   buffer = pfile->buffer;
  update_tokens_line:
-  result->src_loc = pfile->line_table->highest_line;
+  result->src_loc =
+    LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 
  skipped_white:
   if (buffer->cur >= buffer->notes[buffer->cur_note].pos
       && !pfile->overlaid_buffer)
     {
       _cpp_process_line_notes (pfile, false);
-      result->src_loc = pfile->line_table->highest_line;
+      result->src_loc = LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
     }
   c = *buffer->cur++;
 
diff --git a/libcpp/line-map.c b/libcpp/line-map.c
index a82c428..aeccdee 100644
--- a/libcpp/line-map.c
+++ b/libcpp/line-map.c
@@ -23,6 +23,13 @@  along with this program; see the file COPYING3.  If not see
 #include "config.h"
 #include "system.h"
 #include "line-map.h"
+#include "cpp-id-data.h"
+
+#define linemap_assert(EXPR)			\
+  do {						\
+    if (! (EXPR))				\
+      abort ();					\
+  } while (0)
 
 static void trace_include (const struct line_maps *, const struct line_map *);
 
@@ -31,17 +38,11 @@  static void trace_include (const struct line_maps *, const struct line_map *);
 void
 linemap_init (struct line_maps *set)
 {
-  set->maps = NULL;
-  set->allocated = 0;
-  set->used = 0;
-  set->last_listed = -1;
-  set->trace_includes = false;
-  set->depth = 0;
-  set->cache = 0;
-  set->highest_location = RESERVED_LOCATION_COUNT - 1;
-  set->highest_line = RESERVED_LOCATION_COUNT - 1;
-  set->max_column_hint = 0;
-  set->reallocator = 0;
+  memset (set, 0, sizeof (struct line_maps));
+  LINEMAPS_ORDINARY_HIGHEST_LOCATION (set) = RESERVED_LOCATION_COUNT - 1;
+  LINEMAPS_ORDINARY_HIGHEST_LINE (set) = RESERVED_LOCATION_COUNT - 1;
+  LINEMAPS_MACRO_HIGHEST_LOCATION (set) = MAX_SOURCE_LOCATION + 1;
+  LINEMAPS_MACRO_HIGHEST_LINE (set) = MAX_SOURCE_LOCATION + 1;
 }
 
 /* Check for and warn about line_maps entered but not exited.  */
@@ -52,62 +53,168 @@  linemap_check_files_exited (struct line_maps *set)
   struct line_map *map;
   /* Depending upon whether we are handling preprocessed input or
      not, this can be a user error or an ICE.  */
-  for (map = &set->maps[set->used - 1]; ! MAIN_FILE_P (map);
+  for (map = LINEMAPS_LAST_ORDINARY_MAP (set);
+       ! MAIN_FILE_P (map);
        map = INCLUDED_FROM (set, map))
     fprintf (stderr, "line-map.c: file \"%s\" entered but not left\n",
-	     map->to_file);
+	     ORDINARY_MAP_FILE_NAME (map));
 }
  
-/* Free a line map set.  */
+/* Free a line map set.  This should be called only if maps have
+   *NOT* been allocated in garbage memory space.  */
 
 void
 linemap_free (struct line_maps *set)
 {
-  if (set->maps)
+  struct line_map *cur_map;
+  unsigned i;
+
+  /* Free ordinary maps related memory.  */
+  if (LINEMAPS_ORDINARY_MAPS (set))
     {
       linemap_check_files_exited (set);
 
-      free (set->maps);
+      free (LINEMAPS_ORDINARY_MAPS (set));
+      LINEMAPS_ORDINARY_MAPS (set) = NULL;
+    }
+
+  /* Free macro maps related memory.  */
+  if (LINEMAPS_MACRO_MAPS (set))
+    {
+      for (cur_map = LINEMAPS_MACRO_MAPS (set), i = 0;
+	   i < LINEMAPS_MACRO_ALLOCATED (set);
+	   ++i, ++cur_map)
+	{
+	  if (MACRO_MAP_LOCATIONS (LINEMAPS_MACRO_MAP_AT (set, i)))
+	    {
+	      free (MACRO_MAP_LOCATIONS (LINEMAPS_MACRO_MAP_AT (set, i)));
+	      MACRO_MAP_LOCATIONS (LINEMAPS_MACRO_MAP_AT (set, i)) = NULL;
+	    }
+	}
+      free (LINEMAPS_MACRO_MAPS (set));
+      LINEMAPS_MACRO_MAPS (set) = NULL;
     }
 }
 
-/* Add a mapping of logical source line to physical source file and
-   line number.
+/* Returns TRUE if the line table set tracks token locations accross
+   macro expansion, FALSE otherwise.  */
 
-   The text pointed to by TO_FILE must have a lifetime
-   at least as long as the final call to lookup_line ().  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.
+bool
+linemap_tracks_macro_expansion_locs_p (struct line_maps *set)
+{
+  return LINEMAPS_MACRO_MAPS (set) != NULL;
+}
 
-   FROM_LINE should be monotonic increasing across calls to this
-   function.  A call to this function can relocate the previous set of
-   maps, so any stored line_map pointers should not be used.  */
+/* Create a new line map in the line map set SET, and return it.
+   REASON is the reason of creating the map. It determines the type
+   of map created (ordinary or macro map). Note that ordinary maps and
+   macro maps are allocated in different memory location.  */
 
-const struct line_map *
-linemap_add (struct line_maps *set, enum lc_reason reason,
-	     unsigned int sysp, const char *to_file, linenum_type to_line)
+static struct line_map *
+new_linemap (struct line_maps *set,
+	     enum lc_reason reason)
 {
-  struct line_map *map;
-  source_location start_location = set->highest_location + 1;
-
-  if (set->used && start_location < set->maps[set->used - 1].start_location)
-    abort ();
+  /* Depending on this variable, a macro map would be allocated in a
+     different memory location than an ordinary map.  */
+  bool macro_map_p = (reason == LC_ENTER_MACRO);
+  struct line_map *result;
 
-  if (set->used == set->allocated)
+  if (LINEMAPS_USED (set, macro_map_p) == LINEMAPS_ALLOCATED (set, macro_map_p))
     {
+      /* We ran out of allocated line maps. Let's allocate more.  */
+
       line_map_realloc reallocator
 	= set->reallocator ? set->reallocator : xrealloc;
-      set->allocated = 2 * set->allocated + 256;
-      set->maps
-	= (struct line_map *) (*reallocator) (set->maps,
-					      set->allocated
+      LINEMAPS_ALLOCATED (set, macro_map_p) =
+	2 * LINEMAPS_ALLOCATED (set, macro_map_p) + 256;
+      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));
-      memset (&set->maps[set->used], 0, ((set->allocated - set->used)
-					 * sizeof (struct line_map)));
+      result =
+	&LINEMAPS_MAPS (set, macro_map_p)[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)));
+    }
+  else
+    result =
+      &LINEMAPS_MAPS (set, macro_map_p)[LINEMAPS_USED (set, macro_map_p)];
+
+  LINEMAPS_USED (set, macro_map_p)++;
+
+  result->reason = reason;
+  return result;
+}
+
+/* Create an ordinary line map -- a mapping between a logical source
+   location and physical source file and line number.
+
+   SET is the set of line maps the new map will belong to.  The text
+   pointed to by TO_FILE must have a lifetime 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.
+
+   If LC_REASON is LC_RENAME and PREVIOUS is non NULL, it means the
+   line map created by this function is considered to be for the same
+   file as the map PREVIOUS. Setting PREVIOUS to NULL makes the
+   argument to be ignored.
+
+   A call to this function can relocate the previous set of
+   maps, so any stored line_map pointers should not be used.
+
+   This function is a subroutine of linemap_add.  */
+
+static const struct line_map *
+create_and_add_line_map_internal (struct line_maps *set, enum lc_reason reason,
+				  unsigned int sysp, const char *to_file,
+				  linenum_type to_line,
+				  const struct line_map *previous)
+{
+  struct line_map *map = NULL;
+  /* When we are just leaving an "included" file, and jump to the next
+     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 *prev_map_same_file = NULL;
+  source_location start_location = LINEMAPS_ORDINARY_HIGHEST_LOCATION (set) + 1;
+  int previous_index = -1;
+
+  linemap_assert (reason != LC_ENTER_MACRO);
+
+  linemap_assert (!(LINEMAPS_ORDINARY_USED (set)
+		    && (start_location
+			< MAP_START_LOCATION (LINEMAPS_LAST_ORDINARY_MAP (set)))));
+
+  /* If we are leaving the main file, return a NULL map.  */
+  if (reason == LC_LEAVE
+      && MAIN_FILE_P (LINEMAPS_LAST_ORDINARY_MAP (set))
+      && to_file == NULL)
+    {
+      set->depth--;
+      return NULL;
     }
 
-  map = &set->maps[set->used];
+  /*
+     *Kludge* ahead. new_linemap uses ggc_realloc to enlarge
+     line_maps::maps. ggc_realloc frees the previous storage of
+     line_maps::maps. So struct line_map* pointers that where pointing
+     into line_maps::maps prior to new_linemap can become dangling
+     after new_linemap. previous is such a pointer that can become
+     dangling after new_linemap. Let's make sure we make it point into
+     the newly allocated line_maps::maps.
+  */
+  if (previous)
+    previous_index = linemap_map_get_index (set, previous);
+
+  map = new_linemap (set, reason);
+  if (previous_index > -1)
+    previous = &LINEMAPS_ORDINARY_MAPS (set)[previous_index];
 
   if (to_file && *to_file == '\0' && reason != LC_RENAME_VERBATIM)
     to_file = "<stdin>";
@@ -121,27 +228,32 @@  linemap_add (struct line_maps *set, enum lc_reason reason,
     reason = LC_ENTER;
   else if (reason == LC_LEAVE)
     {
-      struct line_map *from;
       bool error;
 
       if (MAIN_FILE_P (map - 1))
 	{
-	  if (to_file == NULL)
-	    {
-	      set->depth--;
-	      return NULL;
-	    }
+	  /* So this _should_ means we are leaving the main file --
+	     effectively ending the compilation unit. But to_file not
+	     being NULL means the caller thinks we are leaving to
+	     another file. This is an erroneous behaviour but we'll
+	     try to recover from it. Let's pretend we are not leaving
+	     the main file.  */
 	  error = true;
-          reason = LC_RENAME;
-          from = map - 1;
+	  reason = LC_RENAME;
+	  prev_map_same_file = map - 1;
 	}
       else
 	{
-	  from = INCLUDED_FROM (set, map - 1);
-	  error = to_file && strcmp (from->to_file, to_file);
+	  /* (MAP - 1) points to the map we are leaving. The
+	     map from which (MAP - 1) got included should be the map
+	     that comes right before MAP in the same file.  */
+	  prev_map_same_file = INCLUDED_FROM (set, map - 1);
+	  linemap_check_ordinary (prev_map_same_file);
+	  error = to_file && strcmp (ORDINARY_MAP_FILE_NAME (prev_map_same_file),
+				     to_file);
 	}
 
-      /* Depending upon whether we are handling preprocessed input or
+      /* Depending on whether we are handling preprocessed input or
 	 not, this can be a user error or an ICE.  */
       if (error)
 	fprintf (stderr, "line-map.c: file \"%s\" left but not entered\n",
@@ -150,55 +262,190 @@  linemap_add (struct line_maps *set, enum lc_reason reason,
       /* A TO_FILE of NULL is special - we use the natural values.  */
       if (error || to_file == NULL)
 	{
-	  to_file = from->to_file;
-	  to_line = SOURCE_LINE (from, from[1].start_location);
-	  sysp = from->sysp;
+	  linemap_check_ordinary (prev_map_same_file);
+	  to_file = ORDINARY_MAP_FILE_NAME (prev_map_same_file);
+	  to_line = SOURCE_LINE (prev_map_same_file,
+				 prev_map_same_file[1].start_location);
+	  sysp = ORDINARY_MAP_IN_SYSTEM_HEADER_P (prev_map_same_file);
 	}
     }
 
-  map->reason = reason;
-  map->sysp = sysp;
-  map->start_location = start_location;
-  map->to_file = to_file;
-  map->to_line = to_line;
-  set->cache = set->used++;
-  map->column_bits = 0;
-  set->highest_location = start_location;
-  set->highest_line = start_location;
+  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;
+  ORDINARY_MAP_STARTING_LINE_NUMBER (map) = to_line;
+  LINEMAPS_ORDINARY_CACHE (set) = LINEMAPS_ORDINARY_USED (set) - 1;
+  ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) = 0;
+  LINEMAPS_ORDINARY_HIGHEST_LOCATION (set) = start_location;
+  LINEMAPS_ORDINARY_HIGHEST_LINE (set) = start_location;
   set->max_column_hint = 0;
 
   if (reason == LC_ENTER)
     {
-      map->included_from = set->depth == 0 ? -1 : (int) (set->used - 2);
+      ORDINARY_MAP_INCLUDER_FILE_INDEX (map)
+	= set->depth == 0 ? -1 : (int) (LINEMAPS_ORDINARY_USED (set) - 2);
       set->depth++;
       if (set->trace_includes)
 	trace_include (set, map);
     }
   else if (reason == LC_RENAME)
-    map->included_from = map[-1].included_from;
+    {
+      if (previous == NULL)
+	previous = &map[-1];
+      linemap_check_ordinary (previous);
+      ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
+	ORDINARY_MAP_INCLUDER_FILE_INDEX (previous);
+    }
   else if (reason == LC_LEAVE)
     {
+      linemap_assert (prev_map_same_file != NULL);
       set->depth--;
-      map->included_from = INCLUDED_FROM (set, map - 1)->included_from;
+      ORDINARY_MAP_INCLUDER_FILE_INDEX (map) =
+		ORDINARY_MAP_INCLUDER_FILE_INDEX (prev_map_same_file);
     }
 
   return map;
 }
 
+/* Add a mapping of logical source line to physical source file and
+   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 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.
+
+   A call to this function can relocate the previous set of
+   maps, so any stored line_map pointers should not be used.  */
+
+const struct line_map *
+linemap_add (struct line_maps *set, enum lc_reason reason,
+	     unsigned int sysp, const char *to_file, linenum_type to_line)
+{
+  return create_and_add_line_map_internal (set, reason, sysp,
+					   to_file, to_line,
+					   NULL);
+}
+
+/*
+   Create a macro map. A macro map encodes source locations of tokens
+   that are part of a macro replacement-list, at a macro expansion
+   point. See the extensive comments of struct line_map and struct
+   line_map_macro, in line-map.h.
+
+   This map shall be created when the macro is expanded. The map
+   encodes the source location of the expansion point of the macro as
+   well as the "original" source location of each token that is part
+   of the macro replacement-list. If a macro is defined but never
+   expanded, it has no macro map.  SET is the set of maps the macro
+   map should be part of.  MACRO is the macro which the new macro map
+   should encode source locations for.  EXPANSION is the location of
+   the expansion point of MACRO. For function-like macros invocations,
+   it's best to make it point to the closing parenthesis 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 *set, struct cpp_macro *macro,
+		     source_location expansion, unsigned int num_tokens)
+{
+  struct line_map *map;
+  source_location start_location = LINEMAPS_MACRO_HIGHEST_LOCATION (set) - 1;
+  line_map_realloc reallocator
+    = set->reallocator ? set->reallocator : xrealloc;
+
+  map = new_linemap (set, LC_ENTER_MACRO);
+
+  MAP_START_LOCATION (map) = start_location;
+  MACRO_MAP_MACRO (map) = macro;
+  MACRO_MAP_NUM_MACRO_TOKENS (map) = num_tokens;
+  MACRO_MAP_LOCATIONS (map)
+    = (source_location*) reallocator (NULL,
+				      2 * num_tokens
+				      * sizeof (source_location));
+  MACRO_MAP_EXPANSION_POINT_LOCATION (map) = expansion;
+  memset (MACRO_MAP_LOCATIONS (map), 0,
+	  num_tokens * sizeof (source_location));
+
+  LINEMAPS_MACRO_CACHE (set) = LINEMAPS_MACRO_USED (set) - 1;
+  set->max_column_hint = 0;
+  LINEMAPS_MACRO_HIGHEST_LOCATION (set) =
+    start_location - num_tokens;
+  LINEMAPS_MACRO_HIGHEST_LINE (set) = 
+    start_location - num_tokens;
+
+  return map;
+}
+
+/* Create and return a source location for a token that is part of a
+   macro replacement-list at a macro expansion point.
+
+   A call to this function must come after a call to
+   linemap_enter_macro.
+
+   MAP is the map into which the source location is created.  TOKEN_NO
+   is the index of the token in the macro replacement-list, starting
+   at number 0.
+
+   ORIG_LOC is the orginal location of the token at the definition
+   point of the macro. If you read the extensive comments of struct
+   line_map_macro in line-map.h, this is the xI.
+
+   If the token is part of a macro argument, ORIG_PARM_REPLACEMENT_LOC
+   is the location of the point at wich the token (the argument)
+   replaces the macro parameter in the context of the relevant macro
+   definition. If you read the comments of struct line_map_macro in
+   line-map.h, this is the yI.  */
+
+source_location
+linemap_add_macro_token (const struct line_map *map,
+			 unsigned int token_no,
+			 source_location orig_loc,
+			 source_location orig_parm_replacement_loc)
+{
+  source_location result;
+
+  linemap_assert (linemap_macro_expansion_map_p (map));
+  linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
+
+  MACRO_MAP_LOCATIONS (map)[2 * token_no] = orig_loc;
+  MACRO_MAP_LOCATIONS (map)[2 * token_no + 1] = orig_parm_replacement_loc;
+  
+  result = MAP_START_LOCATION (map) - token_no;
+  return result;
+}
+
+/* Return a source_location for the start (i.e. column==0) of
+   (physical) line TO_LINE in the current source file (as in the
+   most recent linemap_add).   MAX_COLUMN_HINT is the highest column
+   number we expect to use in this line (but it does not change
+   the highest_location).  */
+
 source_location
 linemap_line_start (struct line_maps *set, linenum_type to_line,
 		    unsigned int max_column_hint)
 {
-  struct line_map *map = &set->maps[set->used - 1];
-  source_location highest = set->highest_location;
+  struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
+  source_location highest = LINEMAPS_ORDINARY_HIGHEST_LOCATION (set);
   source_location r;
-  linenum_type last_line = SOURCE_LINE (map, set->highest_line);
+  linenum_type last_line =
+    SOURCE_LINE (map, LINEMAPS_ORDINARY_HIGHEST_LINE (set));
   int line_delta = to_line - last_line;
   bool add_map = false;
+
+  linemap_check_ordinary (map);
+
   if (line_delta < 0
-      || (line_delta > 10 && line_delta * map->column_bits > 1000)
-      || (max_column_hint >= (1U << map->column_bits))
-      || (max_column_hint <= 80 && map->column_bits >= 10))
+      || (line_delta > 10
+	  && line_delta * ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) > 1000)
+      || (max_column_hint >= (1U << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map)))
+      || (max_column_hint <= 80
+	  && ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) >= 10))
     {
       add_map = true;
     }
@@ -212,7 +459,7 @@  linemap_line_start (struct line_maps *set, linenum_type to_line,
 	  /* If the column number is ridiculous or we've allocated a huge
 	     number of source_locations, give up on column numbers. */
 	  max_column_hint = 0;
-	  if (highest >0xF0000000)
+	  if (highest > MAX_SOURCE_LOCATION)
 	    return 0;
 	  column_bits = 0;
 	}
@@ -226,27 +473,39 @@  linemap_line_start (struct line_maps *set, linenum_type to_line,
       /* Allocate the new line_map.  However, if the current map only has a
 	 single line we can sometimes just increase its column_bits instead. */
       if (line_delta < 0
-	  || last_line != map->to_line
+	  || last_line != ORDINARY_MAP_STARTING_LINE_NUMBER (map)
 	  || SOURCE_COLUMN (map, highest) >= (1U << column_bits))
-	map = (struct line_map *) linemap_add (set, LC_RENAME, map->sysp,
-					       map->to_file, to_line);
-      map->column_bits = column_bits;
-      r = map->start_location + ((to_line - map->to_line) << 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);
+      ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map) = column_bits;
+      r = MAP_START_LOCATION (map) + ((to_line - ORDINARY_MAP_STARTING_LINE_NUMBER (map))
+				 << column_bits);
     }
   else
     r = highest - SOURCE_COLUMN (map, highest)
-      + (line_delta << map->column_bits);
-  set->highest_line = r;
-  if (r > set->highest_location)
-    set->highest_location = r;
+      + (line_delta << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map));
+  LINEMAPS_ORDINARY_HIGHEST_LINE (set) = r;
+  if (r > LINEMAPS_ORDINARY_HIGHEST_LOCATION (set))
+      LINEMAPS_ORDINARY_HIGHEST_LOCATION (set) = r;
   set->max_column_hint = max_column_hint;
   return r;
 }
 
+/* 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.  */
+
 source_location
 linemap_position_for_column (struct line_maps *set, unsigned int to_column)
 {
-  source_location r = set->highest_line;
+  source_location r = LINEMAPS_ORDINARY_HIGHEST_LINE (set);
+
+  linemap_assert
+    (!linemap_macro_expansion_map_p (LINEMAPS_LAST_ORDINARY_MAP (set)));
+
   if (to_column >= set->max_column_hint)
     {
       if (r >= 0xC000000 || to_column > 100000)
@@ -256,35 +515,65 @@  linemap_position_for_column (struct line_maps *set, unsigned int to_column)
 	}
       else
 	{
-	  struct line_map *map = &set->maps[set->used - 1];
+	  struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (set);
 	  r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
 	}
     }
   r = r + to_column;
-  if (r >= set->highest_location)
-    set->highest_location = r;
+  if (r >= LINEMAPS_ORDINARY_HIGHEST_LOCATION (set))
+    LINEMAPS_ORDINARY_HIGHEST_LOCATION (set) = r;
   return r;
 }
 
-/* Given a logical line, returns the map from which the corresponding
-   (source file, line) pair can be deduced.  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.  */
+/* Encode and return a source location from a given line and
+   column.  */
+
+source_location
+linemap_position_for_line_and_column (struct line_map *map,
+				      linenum_type line,
+				      unsigned column)
+{
+  linemap_check_ordinary (map);
+  linemap_assert (ORDINARY_MAP_STARTING_LINE_NUMBER (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)));
+}
+
+/* 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.  */
 
 const struct line_map *
 linemap_lookup (struct line_maps *set, source_location line)
 {
   unsigned int md, mn, mx;
   const struct line_map *cached;
+  bool macro_map_p;
+
+  if (set ==  NULL)
+    return NULL;
 
-  mn = set->cache;
-  mx = set->used;
+  macro_map_p = linemap_location_from_macro_expansion_p (set, line);
+
+  if (LINEMAPS_MAPS (set, macro_map_p) == NULL)
+    return NULL;
+
+  mn = LINEMAPS_CACHE (set, macro_map_p);
+  mx = LINEMAPS_USED (set, macro_map_p);
   
-  cached = &set->maps[mn];
+  cached = &LINEMAPS_MAPS (set, macro_map_p)[mn];
   /* We should get a segfault if no line_maps have been added yet.  */
-  if (line >= cached->start_location)
+  if (LOCATION_POSSIBLY_IN_MAP_P (line, cached, macro_map_p))
     {
-      if (mn + 1 == mx || line < cached[1].start_location)
+      if (mn + 1 == mx || !LOCATION_POSSIBLY_IN_MAP_P (line,
+						       &cached[1],
+						       macro_map_p))
 	return cached;
     }
   else
@@ -296,14 +585,316 @@  linemap_lookup (struct line_maps *set, source_location line)
   while (mx - mn > 1)
     {
       md = (mn + mx) / 2;
-      if (set->maps[md].start_location > line)
+      if (!LOCATION_POSSIBLY_IN_MAP_P (line,
+				       &LINEMAPS_MAPS (set, macro_map_p)[md],
+				       macro_map_p))
 	mx = md;
       else
 	mn = md;
     }
 
-  set->cache = mn;
-  return &set->maps[mn];
+  LINEMAPS_CACHE (set, macro_map_p) = mn;
+  return &LINEMAPS_MAPS (set, macro_map_p)[mn];
+}
+
+/* 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 *map)
+{
+  if (!map)
+    return false;
+  return (map->reason == LC_ENTER_MACRO);
+}
+
+/* Assert that MAP encodes locations of tokens that are not part of the
+   replacement-list of a macro expansion.  */
+
+int
+linemap_check_ordinary (const struct line_map *map)
+{
+  linemap_assert (!linemap_macro_expansion_map_p (map));
+  /* Return any old value.  */
+  return 0;
+}
+
+/* If LOCATION is the locus of a token in a replacement-list of a
+   macro expansion return the location of the macro expansion point.
+
+   Read the comments of struct line_map and struct line_map_macro in
+   line-map.h to understand what a macro expansion point is.  */
+
+source_location
+linemap_macro_map_loc_to_exp_point (const struct line_map *map,
+				    source_location location)
+{
+  unsigned token_no;
+
+  linemap_assert (linemap_macro_expansion_map_p (map)
+		  && LOCATION_POSSIBLY_IN_MACRO_MAP_P (location, map));
+
+  /* Make sure LOCATION is correct.  */
+  token_no = MAP_START_LOCATION (map) - location;
+  linemap_assert (token_no <  MACRO_MAP_NUM_MACRO_TOKENS (map));
+
+  return MACRO_MAP_EXPANSION_POINT_LOCATION (map);
+}
+
+/* If LOCATION is the locus of a token in a replacement-list of a
+   macro expansion return the location of said token in the
+   definition of the macro.
+
+   Read the comments of struct line_map and struct line_map_macro
+   in line-map.h to understand what a macro expansion point is.
+
+   If RETURN_MACRO_PARM_USAGE_POINT_P is TRUE and if LOCATION is the
+   locus of a token that is an argument of a macro M, this function
+   returns the locus of the parameter replaced by the argument, in the
+   definition of M. This is the yI in the comments of struct
+   line_map_macro in line-map.h.
+
+   Note that if the token is a builtin the function returns the
+   location of the expansion point of the macro.  */
+
+source_location
+linemap_macro_map_loc_to_def_point (const struct line_map *map,
+				    source_location location,
+				    bool return_macro_parm_usage_point_p)
+{
+  unsigned token_no;
+  linemap_assert (linemap_macro_expansion_map_p (map)
+		  && LOCATION_POSSIBLY_IN_MACRO_MAP_P (location, map));
+
+  token_no = MAP_START_LOCATION (map) - location;
+  linemap_assert (token_no < MACRO_MAP_NUM_MACRO_TOKENS (map));
+
+  if (return_macro_parm_usage_point_p)
+    location = MACRO_MAP_LOCATIONS (map)[2 * token_no + 1];
+  else
+    location = MACRO_MAP_LOCATIONS (map)[2 * token_no];
+
+  if (location >= RESERVED_LOCATION_COUNT)
+    return location;
+  else
+    /* If LOCATION is reserved for the user of libcpp, it means,
+     e.g. for gcc that it's the location of a built-in token. In that
+     case, let's say that the final location is the macro expansion
+     point because otherwise, the built-in location would not make
+     any sense and would violate the invariant that says that every
+     single location must be >= to the MAP_START_LOCATION (MAP) of its
+     map.  */
+    return MACRO_MAP_EXPANSION_POINT_LOCATION (map);
+}
+
+
+/* If LOCATION is the source location of a token that belongs to a
+   macro replacement-list -- at a macro expansion point-- then
+   return the location of the topmost expansion point of the macro.
+   We say topmost because if we are in the context of a nested macro
+   expansion, the function returns the source location of the first
+   macro expansion that triggered the nested expansions.
+
+   Otherwise, return LOCATION.  SET is the set of maps location come
+   from.  ORIGINAL_MAP is an output parm. If non NULL, the function
+   sets *ORIGINAL_MAP to the ordinary (non-macro) map the returned
+   location comes from.  */
+
+source_location
+linemap_macro_loc_to_exp_point (struct line_maps *set,
+				source_location location,
+				const struct line_map **original_map)
+{
+  struct line_map *map;
+
+  linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
+
+  while (true)
+    {
+      map = (struct line_map*) linemap_lookup (set, location);
+      if (!linemap_macro_expansion_map_p (map))
+	break;
+      location = linemap_macro_map_loc_to_exp_point (map, location);
+    }
+
+  if (original_map)
+    *original_map = map;
+  return location;
+}
+
+/* Return the index of MAP into set. MAP can be either an ordinary or
+   a macro map.  */
+
+int
+linemap_map_get_index (const struct line_maps *set,
+		       const struct line_map* map)
+{
+  int index;
+  bool macro_map_p;
+
+  linemap_assert (set && map);
+
+  macro_map_p = (map->reason == LC_ENTER_MACRO) ? true : false;
+
+  index = map - LINEMAPS_MAPS (set, macro_map_p);
+  linemap_assert (LINEMAPS_MAP_AT (set, macro_map_p, index)  == map);
+
+  return index;
+}
+
+/* If LOCATION is the source location of a token that belongs to a
+   macro replacement-list -- as part of a macro expansion -- then
+   return the location of the token at the definition point of the
+   macro. Otherwise, return LOCATION.  SET is the set of maps location
+   come from.  ORIGINAL_MAP is an output parm. If non NULL, the
+   function sets *ORIGINAL_MAP to the ordinary (non-macro) map
+   the returned location comes from.  */
+
+source_location
+linemap_macro_loc_to_def_point (struct line_maps *set,
+				source_location location,
+				const struct line_map **original_map,
+				bool return_macro_parm_usage_point_p)
+{
+  struct line_map *map;
+
+  linemap_assert (set && location >= RESERVED_LOCATION_COUNT);
+
+  while (true)
+    {
+      map = (struct line_map*) linemap_lookup (set, location);
+      if (!linemap_macro_expansion_map_p (map))
+	break;
+
+      location =
+	linemap_macro_map_loc_to_def_point (map, location,
+					    return_macro_parm_usage_point_p);
+    }
+
+  if (original_map)
+    *original_map = map;
+  return location;
+}
+
+/* Return the source line number corresponding to source location
+   LOCATION.  SET is the line map set LOCATION comes from.  If
+   LOCATION is the source location of token that is part of the
+   replacement-list of a macro expansion return the line number of the
+   macro expansion point.  */
+
+int
+linemap_get_source_line (struct line_maps *set,
+			 source_location location)
+{
+  const struct line_map *map = NULL;
+
+  if (location < RESERVED_LOCATION_COUNT)
+    return 0;
+
+  location =
+    linemap_macro_loc_to_exp_point (set, location, &map);
+  linemap_check_ordinary (map);
+
+  return ((location - MAP_START_LOCATION (map))
+	    >> ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map))
+	 + ORDINARY_MAP_STARTING_LINE_NUMBER (map);
+}
+
+/* Return the column number corresponding to location LOCATION.
+
+   If LOCATION is the source location of token that is part of the
+   replacement-list of a macro expansion return the column number of
+   the macro expansion point.
+
+   SET is the line map set LOCATION comes from.  */
+
+int
+linemap_get_source_column (struct line_maps *set,
+			   source_location location)
+{
+  const struct line_map *map = NULL;
+
+  if (location < RESERVED_LOCATION_COUNT)
+    return 0;
+
+  location =
+    linemap_macro_loc_to_exp_point (set, location, &map);
+  linemap_check_ordinary (map);
+
+  return (location - MAP_START_LOCATION (map))
+	  & ((1 << ORDINARY_MAP_NUMBER_OF_COLUMN_BITS (map)) - 1);
+}
+
+/* Return the path of the file corresponding to source code location
+   LOCATION.
+
+   If LOCATION is the source location of token that is part of the
+   replacement-list of a macro expansion return the file path of the
+   macro expansion point.
+
+   SET is the line map set LOCATION comes from.  */
+
+const char*
+linemap_get_file_path (struct line_maps *set,
+		       source_location location)
+{
+  const struct line_map *map = NULL;
+
+  if (location < RESERVED_LOCATION_COUNT)
+    return NULL;
+
+  location =
+    linemap_macro_loc_to_exp_point (set, location, &map);
+  linemap_check_ordinary (map);
+  return LINEMAP_FILE (map);
+}
+
+/* Return the name of the macro associated to MACRO_MAP.  */
+
+const char*
+linemap_map_get_macro_name (const struct line_map* macro_map)
+{
+  linemap_assert (macro_map && linemap_macro_expansion_map_p (macro_map));
+  return (const char*) NODE_NAME (MACRO_MAP_MACRO (macro_map)->name);
+}
+
+/* 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 0 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 *set,
+				     source_location location)
+{
+  const struct line_map *map = NULL;
+
+  if (location < RESERVED_LOCATION_COUNT)
+    return false;
+
+  location =
+    linemap_macro_loc_to_def_point (set, location, &map, false);
+  linemap_check_ordinary (map);
+  return LINEMAP_SYSP (map);
+}
+
+/* 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 *set,
+					 source_location location)
+{
+  linemap_assert (location <= MAX_SOURCE_LOCATION);
+  if (set == NULL)
+    return false;
+  return (location > LINEMAPS_ORDINARY_HIGHEST_LOCATION (set));
 }
 
 /* Print an include trace, for e.g. the -H option of the preprocessor.  */
@@ -315,5 +906,78 @@  trace_include (const struct line_maps *set, const struct line_map *map)
 
   while (--i)
     putc ('.', stderr);
-  fprintf (stderr, " %s\n", map->to_file);
+  linemap_check_ordinary (map);
+  fprintf (stderr, " %s\n", ORDINARY_MAP_FILE_NAME (map));
+}
+
+/* Expand source code location LOC and return a user readable source
+   code 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.
+
+   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 function expands the location to the locus of the
+   expansion point of the macro.
+
+   * If LRK is set to LRK_SPELLING_LOCATION
+   -------------------------------------
+
+   The function expands the location 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_PARM_REPLACEMENT_POINT
+   --------------------------------------
+
+   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 function expands 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.  */
+
+expanded_location
+linemap_expand_location_full (struct line_maps *set,
+			      source_location loc,
+			      enum location_resolution_kind lrk,
+			      const struct line_map **loc_map)
+{
+  const struct line_map *map;
+  expanded_location xloc;
+
+  linemap_assert (set && loc >= RESERVED_LOCATION_COUNT);
+
+  switch (lrk)
+    {
+    case LRK_MACRO_EXPANSION_POINT:
+      loc = linemap_macro_loc_to_exp_point (set, loc, &map);
+      break;
+    case LRK_SPELLING_LOCATION:
+      loc = linemap_macro_loc_to_def_point (set, loc, &map, false);
+      break;
+    case LRK_MACRO_PARM_REPLACEMENT_POINT:
+      loc = linemap_macro_loc_to_def_point (set, loc, &map, true);
+      break;
+    default:
+      abort ();
+    }
+
+  xloc.file = LINEMAP_FILE (map);
+  xloc.line = SOURCE_LINE (map, loc);
+  xloc.column = SOURCE_COLUMN (map, loc);
+  xloc.sysp = LINEMAP_SYSP (map) != 0;
+  if (loc_map)
+    *loc_map = map;
+
+  return xloc;
 }
diff --git a/libcpp/macro.c b/libcpp/macro.c
index d9324a3..419114c 100644
--- a/libcpp/macro.c
+++ b/libcpp/macro.c
@@ -171,13 +171,16 @@  _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
 	unsigned int len;
 	const char *name;
 	uchar *buf;
-	map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
+	map =
+	  linemap_lookup (pfile->line_table,
+			  LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table));
 
 	if (node->value.builtin == BT_BASE_FILE)
 	  while (! MAIN_FILE_P (map))
 	    map = INCLUDED_FROM (pfile->line_table, map);
 
-	name = map->to_file;
+	linemap_check_ordinary (map);
+	name = map->d.ordinary.to_file;
 	len = strlen (name);
 	buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
 	result = buf;
@@ -196,14 +199,15 @@  _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
       break;
 
     case BT_SPECLINE:
-      map = &pfile->line_table->maps[pfile->line_table->used-1];
+      map = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
       /* If __LINE__ is embedded in a macro, it must expand to the
 	 line of the macro's invocation, not its definition.
 	 Otherwise things like assert() will not work properly.  */
-      number = SOURCE_LINE (map, 
-			    CPP_OPTION (pfile, traditional) 
-			    ? pfile->line_table->highest_line
-			    : pfile->cur_token[-1].src_loc);
+      number = linemap_get_source_line (pfile->line_table,
+					CPP_OPTION (pfile, traditional)
+					? LINEMAPS_ORDINARY_HIGHEST_LINE
+					(pfile->line_table)
+					: pfile->cur_token[-1].src_loc);
       break;
 
       /* __STDC__ has the value 1 under normal circumstances.
@@ -1857,6 +1861,7 @@  _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
       (sizeof (cpp_macro));
   else
     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
+  macro->name = node;
   macro->line = pfile->directive_line;
   macro->params = 0;
   macro->paramc = 0;
diff --git a/libcpp/traditional.c b/libcpp/traditional.c
index 7ff11bb..5034b3f 100644
--- a/libcpp/traditional.c
+++ b/libcpp/traditional.c
@@ -149,7 +149,7 @@  static const uchar *
 copy_comment (cpp_reader *pfile, const uchar *cur, int in_define)
 {
   bool unterminated, copy = false;
-  source_location src_loc = pfile->line_table->highest_line;
+  source_location src_loc = LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
   cpp_buffer *buffer = pfile->buffer;
 
   buffer->cur = cur;
@@ -365,7 +365,7 @@  _cpp_scan_out_logical_line (cpp_reader *pfile, cpp_macro *macro)
   CUR (pfile->context) = pfile->buffer->cur;
   RLIMIT (pfile->context) = pfile->buffer->rlimit;
   pfile->out.cur = pfile->out.base;
-  pfile->out.first_line = pfile->line_table->highest_line;
+  pfile->out.first_line = LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
   /* start_of_input_line is needed to make sure that directives really,
      really start at the first character of the line.  */
   start_of_input_line = pfile->buffer->cur;
@@ -493,7 +493,8 @@  _cpp_scan_out_logical_line (cpp_reader *pfile, cpp_macro *macro)
 		    {
 		      maybe_start_funlike (pfile, node, out_start, &fmacro);
 		      lex_state = ls_fun_open;
-		      fmacro.line = pfile->line_table->highest_line;
+		      fmacro.line =
+			LINEMAPS_ORDINARY_HIGHEST_LINE (pfile->line_table);
 		      continue;
 		    }
 		  else if (!recursive_macro (pfile, node))