Add DWARF index cache

New in v3:

- Remove things related to the dwarf-5 format.
- Fix compilation on mingw (scoped_mmap.c).

GDB can generate indexes for DWARF debug information, which, when
integrated in the original binary, can speed up loading object files.
This can be done using the gdb-add-index script or directly by the
linker itself.  However, not many people know about this.  And even
among those who do, because it requires additional steps, I don't know a
lot of people who actually go through that trouble.

To help make using the DWARF index more transparent, this patch
introduces a DWARF index cache.  When enabled, loading an index-less
binary in GDB will automatically save an index file in ~/.cache/gdb.
When loading that same object file again, the index file will be looked
up and used to load the DWARF index.  You therefore get the benefit of
the DWARF index without having to do additional manual steps or
modifying your build system.  When an index section is already present
in the file, GDB will prefer that one over looking up the cache.

When doing my edit-compile-debug cycle, I often debug multiple times the
same build, so the cache helps reducing the load time of the debug
sessions after the first one.

- The saved index file is exactly the same as the output of the "save
  gdb-index" command.  It is therefore the exact same content that would
  be found in the .gdb_index or .debug_names section.  We just leave it
  as a standalone file instead of merging it in the binary.

- The cache is just a directory with files named after the object
  file's build-id.  It is not possible to save/load the index for an
  object file without build-id in the cache.

- The cache uses the gdb index format.  The problem with the dwarf-5
  format is that we can generate an addendum to the .debug_str section
  that you're supposed to integrate to the original binary.  This
  complicates a little bit loading the data from the cached index files,
  so I would leave this for later.

- The size taken up by ~/.cache/gdb is not limited.  I was thinking we
  could add configurable limit (like ccache does), but that would come
  after.  Also, maybe a command to flush the cache.

- The cache is disabled by default.  I think once it's been out there
  and tested for a while, it could be turned on by default, so that
  everybody can enjoy it.

- The code was made to follow the XDG specification: if the
  XDG_CACHE_HOME environment variable, it is used, otherwise it falls
  back to ~/.cache/gdb.  It is possible to change it using "set
  index-cache directory".  On other OSes than GNU/Linux, ~/.cache may
  not be the best place to put such data.  On macOS it should probably
  default to ~/Library/Caches/...  On Windows, %LocalAppData%/...  I
  don't intend to do this part, but further patches are welcome.

- I think that we need to be careful that multiple instances of GDB
  don't interfere with each other (not far fetched at all if you run GDB
  in some automated script) and the cache is always coherent (either the
  file is not found, or it is found and entirely valid).  Writing the
  file directly to its final location seems like a recipe for failure.
  One GDB could read a file in the index while it is being written by
  another GDB.  To mitigate this, I made write_psymtabs_to_index write
  to temporary files and rename them once it's done.  Two GDB instances
  writing the index for the same file should not step on each other's
  toes (the last file to be renamed will stay).  A GDB looking up a file
  will only see a complete file or no file.  Also, if GDB crashes while
  generating the index file, it will leave a work-in-progress file, but
  it won't be picked up by other instances looking up in the cache.

gdb/ChangeLog:

	* common/pathstuff.h (get_standard_cache_dir): New.
	* common/pathstuff.c (get_standard_cache_dir): New.
	* build-id.h (build_id_to_string): New.
	* dwarf-index-common.h (INDEX4_SUFFIX, INDEX5_SUFFIX,
	DEBUG_STR_SUFFIX): Move to here.
	* dwarf-index-write.c (INDEX4_SUFFIX, INDEX5_SUFFIX,
	DEBUG_STR_SUFFIX): Move from there.
	(write_psymtabs_to_index): Make non-static, add basename
	parameter.  Write to temporary files, rename when done.
	(save_gdb_index_command): Adjust call to
	write_psymtabs_to_index.
	* dwarf2read.h (dwarf2_per_objfile) <index_cache_res>: New
	field.
	* dwarf2read.c (dwz_file) <index_cache_res>: New field.
	(get_gdb_index_contents_from_cache): New.
	(get_gdb_index_contents_from_cache_dwz): New.
	(dwarf2_initialize_objfile): Read index from cache.
	(dwarf2_build_psymtabs): Save to index.
	* dwarf-index-cache.h: New file.
	* dwarf-index-cache.c: New file.
	* dwarf-index-write.h: New file.

gdb/testsuite/ChangeLog:

	* boards/index-cache-gdb.exp: New file.
	* gdb.dwarf2/index-cache.exp: New file.
	* gdb.dwarf2/index-cache.c: New file.
	* gdb.base/maint.exp: Check if we are using the index cache.

1 files changed, 112 insertions, 0 deletions

diff --git a/gdb/dwarf-index-cache.h b/gdb/dwarf-index-cache.h
new file mode 100644
index 0000000..b4fa8c4
--- /dev/null
+++ b/gdb/dwarf-index-cache.h
@@ -0,0 +1,112 @@
+/* Caching of GDB/DWARF index files.
+
+   Copyright (C) 2018 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef DWARF_INDEX_CACHE_H
+#define DWARF_INDEX_CACHE_H
+
+#include "dwarf-index-common.h"
+#include "common/array-view.h"
+#include "symfile.h"
+
+/* Base of the classes used to hold the resources of the indices loaded from
+   the cache (e.g. mmapped files).  */
+
+struct index_cache_resource
+{
+  virtual ~index_cache_resource () = 0;
+};
+
+/* Class to manage the access to the DWARF index cache.  */
+
+class index_cache
+{
+public:
+  /* Change the directory used to save/load index files.  */
+  void set_directory (std::string dir);
+
+  /* Return true if the usage of the cache is enabled.  */
+  bool enabled () const
+  {
+    return m_enabled;
+  }
+
+  /* Enable the cache.  */
+  void enable ();
+
+  /* Disable the cache.  */
+  void disable ();
+
+  /* Store an index for the specified object file in the cache.  */
+  void store (struct dwarf2_per_objfile *dwarf2_per_objfile);
+
+  /* Look for an index file matching BUILD_ID.  If found, return the contents
+     as an array_view and store the underlying resources (allocated memory,
+     mapped file, etc) in RESOURCE.  The returned array_view is valid as long
+     as RESOURCE is not destroyed.
+
+     If no matching index file is found, return an empty array view.  */
+  gdb::array_view<const gdb_byte>
+  lookup_gdb_index (const bfd_build_id *build_id,
+		    std::unique_ptr<index_cache_resource> *resource);
+
+  /* Return the number of cache hits.  */
+  unsigned int n_hits () const
+  { return m_n_hits; }
+
+  /* Record a cache hit.  */
+  void hit ()
+  {
+    if (enabled ())
+      m_n_hits++;
+  }
+
+  /* Return the number of cache misses.  */
+  unsigned int n_misses () const
+  { return m_n_misses; }
+
+  /* Record a cache miss.  */
+  void miss ()
+  {
+    if (enabled ())
+      m_n_misses++;
+  }
+
+private:
+
+  /* Compute the absolute filename where the index of the objfile with build
+     id BUILD_ID will be stored.  SUFFIX is appended at the end of the
+     filename.  */
+  std::string make_index_filename (const bfd_build_id *build_id,
+				   const char *suffix) const;
+
+  /* The base directory where we are storing and looking up index files.  */
+  std::string m_dir;
+
+  /* Whether the cache is enabled.  */
+  bool m_enabled = false;
+
+  /* Number of cache hits and misses during this GDB session.  */
+  unsigned int m_n_hits = 0;
+  unsigned int m_n_misses = 0;
+};
+
+/* The global instance of the index cache.  */
+extern index_cache global_index_cache;
+
+#endif /* DWARF_INDEX_CACHE_H */