Adding upstream version 0.15.upstream/0.15upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 16872 insertions, 0 deletions

diff --git a/dwz.c b/dwz.c
new file mode 100644
index 0000000..3bc6038
--- /dev/null
+++ b/dwz.c
@@ -0,0 +1,16872 @@
+/* Copyright (C) 2001-2021 Red Hat, Inc.
+   Copyright (C) 2003 Free Software Foundation, Inc.
+   Copyright (C) 2019-2021 SUSE LLC.
+   Written by Jakub Jelinek <jakub@redhat.com>, 2012.
+
+   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 2, 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; see the file COPYING.  If not, write to
+   the Free Software Foundation, 51 Franklin Street - Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+#include <assert.h>
+#include <errno.h>
+#include <error.h>
+#include <fcntl.h>
+#include <setjmp.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/times.h>
+#include <sys/wait.h>
+
+#include <obstack.h>
+
+#include <gelf.h>
+#include <xxhash.h>
+
+#include "dwarf2.h"
+#include "hashtab.h"
+#include "sha1.h"
+#include "args.h"
+#include "util.h"
+#include "pool.h"
+
+#ifndef SHF_COMPRESSED
+ /* Glibc elf.h contains SHF_COMPRESSED starting v2.22.  Libelf libelf.h has
+    a fallback definition starting v0.166.  Define a fallback definition here
+    for the case of both pre-v2.22 glibc and pre-v0.166 libelf.  */
+# define SHF_COMPRESSED (1 << 11)  /* Section with compressed data.  */
+#endif
+
+/* Theory of operation:
+   The DWZ tool can either optimize debug sections of a single
+   executable or shared library at a time, or, when -m option
+   is used, optimize debug sections even in between different
+   executables or shared libraries by constructing a new ET_REL
+   ELF object containing debug sections to which the individual
+   debug sections in the various executables or shared libraries
+   can refer.  As debug info can be pretty large, the multifile
+   optimization is done in several phases in order to decrease
+   memory usage of the tool, which can still be quite high.
+
+   The dwz () function optimizes a single file, and at the end,
+   after processing that single file, it frees all allocated memory.
+   Without -m, the dwz () function is called once on each argument.
+
+   When -m has been passed, the dwz () function is first called on
+   each argument, and during it in addition to performing the same
+   optimizations as dwz tool does without -m it also may append
+   data to several temporary files (one for each .debug_* section
+   that is needed for the multifile optimization).  During
+   preparation of the additions to the temporary files (write_multifile
+   function), wr_multifile flag is true.
+
+   Next phase (optimize_multifile) is that all these temporary files
+   are mmapped, it is determined what DIEs, strings, .debug_macro
+   sequences etc. might be beneficial to have in the common debug
+   sections and finally a new ET_REL ELF object is written.  During
+   this phase the op_multifile flag is true.  This is often very
+   memory consuming phase, so extra hacks are used to decrease
+   the memory usage during it.
+
+   Next phase (read_multifile) is where the previously written ET_REL
+   ELF object is parsed again and needed hash tables and other data
+   structures filled in.  The rd_multifile flag is set during this
+   phase.  The reason why this phase is separate from the previous one,
+   as opposed to just populating the hash tables right away in
+   optimize_multifile, is that the memory consumption during that phase
+   can be very big and keeping malloced data around would mean the address
+   space would be unnecessarily fragmented.  read_multifile usually needs
+   to allocate only small fragment of the memory optimize_multifile
+   needs, on the other side that memory needs to be kept around until
+   the end of the last phase.
+
+   During the last phase, the dwz () function is called second
+   time on each argument, with fi_multifile flag set.  During this
+   phase duplicates in the common debug sections are referenced
+   from the local debug sections where possible.
+
+   If some executable or shared library has too large debug information
+   (number of DIEs in .debug_info section) that there would be
+   risk of too high memory consumption, that file isn't multifile
+   optimized, instead it is processed by dwz () in a low-memory mode
+   with low_mem flag set.  This can decrease memory consumption to
+   half in some very large cases.  */
+
+#ifndef NT_GNU_BUILD_ID
+# define NT_GNU_BUILD_ID 3
+#endif
+
+/* xxHash state object.  Init in main.  */
+static XXH64_state_t *state;
+
+/* Clear xxHash state to zero.  */
+#define hash_init_state() XXH64_reset(state, 0)
+
+/* Update hash STATE with VALUE.  */
+#define hash_update_state_object(value) XXH64_update(state, &value, sizeof value)
+
+/* Update hash STATE with OBJECT that has a provided SIZE.  */
+#define hash_update_state(object, size) XXH64_update(state, object, size)
+
+/* Get digest once we are done with a state.  */
+#define hash_digest() XXH64_digest(state)
+
+/* Shorthand for hashing something with an intrinsic size.  */
+#define hash(IN,LEN) XXH64(IN, LEN, 0)
+#define iterative_hash(IN,LEN,INIT) XXH64(IN, LEN, INIT)
+#define iterative_hash_object(OB,INIT) iterative_hash (&OB, sizeof (OB), INIT)
+
+/* Print memory amount M (in kb) in both exact and human readable, like so:
+   1382508 (1.3G).  */
+static void
+print_mem (long m)
+{
+  float h = m;
+  int level = 0;
+  const char *unit[] = { "K", "M", "G"};
+  while (h > 1024 && level <= 2)
+    {
+      h = h / 1024;
+      level++;
+    }
+  fprintf (stderr, "%ld (%.1f%s)\n", m, h, unit[level]);
+}
+
+static void
+report_progress (void)
+{
+  static struct tms current;
+  static struct tms prev;
+  static bool first = true;
+  static long ticks_per_second = 0;
+
+  if (!first)
+    prev = current;
+
+  times (&current);
+
+  if (first)
+    {
+      ticks_per_second = sysconf (_SC_CLK_TCK);
+      first = false;
+      return;
+    }
+
+  clock_t user = current.tms_utime - prev.tms_utime;
+  clock_t sys = current.tms_stime - prev.tms_stime;
+  fprintf (stderr, "user: %.2f\n", (float)user / (float)ticks_per_second);
+  fprintf (stderr, "sys : %.2f\n", (float)sys / (float)ticks_per_second);
+
+  if (progress_mem_p)
+    {
+      FILE *s = fopen ("/proc/self/status", "r");
+      char *p;
+      bool print_next = false;
+      for (p = NULL; fscanf (s, "%ms", &p) && p != NULL; free (p))
+	{
+	  if (print_next)
+	    {
+	      long mem = strtol (p, NULL, 10);
+	      print_mem (mem);
+	      print_next = false;
+	      continue;
+	    }
+
+	  if (!(p[0] == 'V' && p[1] == 'm'))
+	    continue;
+
+	  if (strcmp (&p[2], "Peak:") == 0)
+	    fprintf (stderr, "VM Peak: ");
+	  else if (strcmp (&p[2], "Size:") == 0)
+	    fprintf (stderr, "VM Current: ");
+	  else if (strcmp (&p[2], "HWM:") == 0)
+	    fprintf (stderr, "RSS Peak: ");
+	  else if (strcmp (&p[2], "RSS:") == 0)
+	    fprintf (stderr, "RSS Current: ");
+	  else
+	    continue;
+
+	  print_next = true;
+	}
+      fclose (s);
+    }
+}
+
+#define obstack_chunk_alloc     malloc
+#define obstack_chunk_free      free
+
+/* Where to longjmp on OOM.  */
+static jmp_buf oom_buf;
+
+/* Handle OOM situation.  If handling more than one file, we might
+   just fail to handle some large file due to OOM, but could very well
+   handle other smaller files after it.  */
+void
+dwz_oom (void)
+{
+  longjmp (oom_buf, 1);
+}
+
+/* General obstack for struct dw_cu, dw_die, also used for temporary
+   vectors.  */
+static struct obstack ob;
+/* Short lived obstack, global only to free it on allocation failures.  */
+static struct obstack ob2;
+
+/* After read_multifile ob and ob2 are moved over to these variables
+   and restored during final cleanup.  */
+static struct obstack alt_ob, alt_ob2;
+
+static bool odr_active_p = false;
+
+/* Struct to gather statistics.  */
+struct stats
+{
+  const char *file;
+  unsigned int root_cnt;
+  unsigned int namespace_cnt;
+  unsigned int lower_toplevel;
+  unsigned int die_count;
+  unsigned int lower_toplevel_with_checksum;
+  unsigned int dup_cnt;
+  unsigned int dup_chain_cnt;
+  unsigned int dup_chain_max_length;
+  unsigned int part_cnt;
+  unsigned int pu_ph1_cnt;
+  unsigned int pu_ph2_cnt;
+  unsigned int pu_toplevel_die_cnt;
+};
+static struct stats *stats;
+
+/* Initialize stats struct.  */
+static void
+init_stats (const char *file)
+{
+  if (stats == NULL)
+    stats = (struct stats *)malloc (sizeof (*stats));
+  memset (stats, 0, sizeof (*stats));
+  stats->file = file;
+}
+
+/* Print stats struct, parsing statistics.  */
+static void
+print_parse_stats (void)
+{
+  if (stats == NULL || stats->file == NULL)
+    return;
+
+  fprintf (stderr, "Parse statistics for %s\n", stats->file);
+
+  fprintf (stderr, "root_count                     : %10u\n",
+	   stats->root_cnt);
+  fprintf (stderr, "namespace_count                : %10u\n",
+	   stats->namespace_cnt);
+  unsigned int upper_toplevel = stats->root_cnt + stats->namespace_cnt;
+  fprintf (stderr, "upper_toplevel                 : %10u\n",
+	   upper_toplevel);
+  unsigned lower_toplevel
+    = stats->lower_toplevel + stats->lower_toplevel_with_checksum;
+  fprintf (stderr, "lower_toplevel                 : %10u\n",
+	   lower_toplevel);
+  unsigned int toplevel = upper_toplevel + lower_toplevel;
+  fprintf (stderr, "toplevel                       : %10u\n",
+	   toplevel);
+  unsigned non_toplevel = stats->die_count - toplevel;
+  fprintf (stderr, "non_toplevel                   : %10u\n",
+	   non_toplevel);
+  fprintf (stderr, "die_count                      : %10u\n",
+	   stats->die_count);
+}
+
+/* Print stats struct, dups statistics.  */
+static void
+print_dups_stats (void)
+{
+  if (stats == NULL || stats->file == NULL)
+    return;
+
+  fprintf (stderr, "Duplicate statistics for %s\n", stats->file);
+
+  fprintf (stderr, "lower_toplevel with checksum   : %10u\n",
+	   stats->lower_toplevel_with_checksum);
+  fprintf (stderr, "dup_cnt                        : %10u\n",
+	   stats->dup_cnt);
+  fprintf (stderr, "dup_chain_cnt                  : %10u\n",
+	   stats->dup_chain_cnt);
+  fprintf (stderr, "average dup_chain length       : %10.2f\n",
+	   (double)stats->dup_cnt / (double)stats->dup_chain_cnt);
+  fprintf (stderr, "max dup_chain length           : %10u\n",
+	   stats->dup_chain_max_length);
+}
+
+static void
+print_part_stats (void)
+{
+  if (stats == NULL || stats->file == NULL)
+    return;
+
+  fprintf (stderr, "Partition statistics for %s\n", stats->file);
+
+  fprintf (stderr, "part_cnt                       : %10u\n", stats->part_cnt);
+  fprintf (stderr, "pu_ph1_cnt                     : %10u\n",
+	   stats->pu_ph1_cnt);
+  fprintf (stderr, "pu_ph2_cnt                     : %10u\n",
+	   stats->pu_ph2_cnt);
+  fprintf (stderr, "pu_cnt                         : %10u\n",
+	   stats->pu_ph1_cnt + stats->pu_ph2_cnt);
+  fprintf (stderr, "pu_toplevel_die_cnt            : %10u\n",
+	   stats->pu_toplevel_die_cnt);
+}
+
+typedef struct
+{
+  Elf *elf;
+  GElf_Ehdr ehdr;
+  Elf_Scn **scn;
+  const char *filename;
+  int lastscn;
+  GElf_Shdr shdr[0];
+} DSO;
+
+/* Macro to parse an uleb128 number, return it and
+   update ptr to the end of the uleb128 at the same time.  */
+#define read_uleb128(ptr) ({		\
+  uint64_t ret = 0;			\
+  uint64_t c;				\
+  int shift = 0;			\
+  do					\
+    {					\
+      c = *ptr++;			\
+      ret |= (c & 0x7f) << shift;	\
+      shift += 7;			\
+    } while (c & 0x80);			\
+					\
+  if (shift >= 70)			\
+    ret = ~(uint64_t) 0;		\
+  ret;					\
+})
+
+/* Macro to parse a sleb128 number, return it and
+   update ptr to the end of the sleb128 at the same time.  */
+#define read_sleb128(ptr) ({		\
+  uint64_t ret = 0;			\
+  uint64_t c;				\
+  int shift = 0;			\
+  do					\
+    {					\
+      c = *ptr++;			\
+      ret |= (c & 0x7f) << shift;	\
+      shift += 7;			\
+    } while (c & 0x80);			\
+					\
+  if (shift >= 70)			\
+    ret = ~(uint64_t) 0;		\
+  else if (c & 0x40)			\
+    ret |= (-(uint64_t) 1) << shift;	\
+  ret;					\
+})
+
+/* Macro to store an uleb128 number to ptr and update
+   ptr to point after it.  */
+#define write_uleb128(ptr, val)		\
+  do					\
+    {					\
+      uint64_t valv = (val);		\
+      do				\
+	{				\
+	  unsigned char c = valv & 0x7f;\
+	  valv >>= 7;			\
+	  if (valv)			\
+	    c |= 0x80;			\
+	  *ptr++ = c;			\
+	}				\
+      while (valv);			\
+    }					\
+  while (0)
+
+#define write_sleb128(ptr, val)					\
+  do								\
+    {								\
+      int64_t valv = (val);					\
+      bool more;						\
+      do							\
+	{							\
+	  unsigned char c = valv & 0x7f;			\
+	  valv >>= 7;						\
+	  more = ((valv != 0 || (c & 0x40) != 0)                \
+		  && (valv != -1 || (c & 0x40) == 0));          \
+	  if (more)						\
+	    c |= 0x80;						\
+	  *ptr++ = c;						\
+	}							\
+      while (more);						\
+    }								\
+  while (0)
+
+/* Macro to skip a uleb128 or sleb128 number and update ptr to the end of the
+   number.  */
+#define skip_leb128(ptr) \
+  do {} while ((*ptr++) & 0x80)
+
+/* Macro to parse a uint16_t value represented using form, return it and
+   update ptr to the end of the value at the same time.  If the value doesn't
+   fit, assign true to error_p.  */
+#define read_u16(ptr, form, error_p)			\
+  ({							\
+    uint16_t ret = 0;					\
+    switch (form)					\
+      {							\
+      case DW_FORM_data1:				\
+	ret = read_8 (ptr);				\
+	break;						\
+      case DW_FORM_data2:				\
+	ret = read_16 (ptr);				\
+	break;						\
+      case DW_FORM_data4:				\
+	{						\
+	  uint32_t res = read_32 (ptr);			\
+	  ret = (uint16_t)res;				\
+	  if ((uint32_t)ret != res)			\
+	    error_p = true;				\
+	  break;					\
+	}						\
+      case DW_FORM_data8:				\
+	{						\
+	  uint64_t res = read_64 (ptr);			\
+	  ret = (uint16_t)res;				\
+	  if ((uint64_t)ret != res)			\
+	    error_p = true;				\
+	  break;					\
+	}						\
+      case DW_FORM_udata:				\
+	{						\
+	  uint64_t res = read_uleb128 (ptr);		\
+	  ret = (uint16_t)res;				\
+	  if ((uint64_t)ret != res)			\
+	    error_p = true;				\
+	  break;					\
+	}						\
+      case DW_FORM_sdata:				\
+	{						\
+	  union {					\
+	    uint64_t u;					\
+	    int64_t i;					\
+	  } res;					\
+	  res.u = read_sleb128 (ptr);			\
+	  ret = (uint16_t)res.u;			\
+	  if (res.i < 0 || (uint64_t)ret != res.u)	\
+	    error_p = true;				\
+	  break;					\
+	}						\
+      default:						\
+	error_p = true;					\
+	break;						\
+      }							\
+    ret;						\
+  })
+
+/* Pointer size in the debug info, in bytes.  Only debug info
+   with a single pointer size are handled.  */
+static int ptr_size;
+
+/* Lowest debug_line version we have seen.  When writing out the multi
+   file .debug_line we'll only use a DWARF5 version when there is no
+   lower line table seen (since the debug_line dir and file table is
+   shared between all CUs).  */
+static unsigned int lowest_line_version = 5;
+
+/* Utility functions and macros for reading/writing values in
+   given ELF endianity, which might be different from host endianity.
+   No specific alignment is expected.  */
+static uint16_t (*do_read_16) (unsigned char *ptr);
+static uint32_t (*do_read_32) (unsigned char *ptr);
+static uint64_t (*do_read_64) (unsigned char *ptr);
+static void (*do_write_16) (unsigned char *ptr, unsigned short val);
+static void (*do_write_32) (unsigned char *ptr, unsigned int val);
+static void (*do_write_64) (unsigned char *ptr, uint64_t val);
+
+static inline uint16_t
+buf_read_ule16 (unsigned char *data)
+{
+  return data[0] | (data[1] << 8);
+}
+
+static inline uint16_t
+buf_read_ube16 (unsigned char *data)
+{
+  return data[1] | (data[0] << 8);
+}
+
+static inline uint32_t
+buf_read_ule32 (unsigned char *data)
+{
+  return (data[0] | (data[1] << 8) | (data[2] << 16)
+	  | ((unsigned int)data[3] << 24));
+}
+
+static inline uint32_t
+buf_read_ube32 (unsigned char *data)
+{
+  return (data[3] | (data[2] << 8) | (data[1] << 16)
+	  | ((unsigned int)data[0] << 24));
+}
+
+static inline uint64_t
+buf_read_ule64 (unsigned char *data)
+{
+  return buf_read_ule32 (data)
+	 | (((uint64_t) buf_read_ule32 (data + 4)) << 32);
+}
+
+static inline uint64_t
+buf_read_ube64 (unsigned char *data)
+{
+  return (((uint64_t) buf_read_ube32 (data)) << 32)
+	 | buf_read_ube32 (data + 4);
+}
+
+#define read_8(ptr) *ptr++
+
+#define read_16(ptr) ({					\
+  uint16_t ret = do_read_16 (ptr);			\
+  ptr += 2;						\
+  ret;							\
+})
+
+#define read_32(ptr) ({					\
+  uint32_t ret = do_read_32 (ptr);			\
+  ptr += 4;						\
+  ret;							\
+})
+
+#define read_64(ptr) ({					\
+  uint64_t ret = do_read_64 (ptr);			\
+  ptr += 8;						\
+  ret;							\
+})
+
+#define write_8(ptr, val)				\
+  do							\
+    *ptr++ = (val);					\
+  while (0)
+
+#define write_16(ptr, val)				\
+  do							\
+    {							\
+      do_write_16 (ptr, val);				\
+      ptr += 2;						\
+    }							\
+  while (0)
+
+#define write_32(ptr, val)				\
+  do							\
+    {							\
+      do_write_32 (ptr, val);				\
+      ptr += 4;						\
+    }							\
+  while (0)
+
+#define write_64(ptr, val)				\
+  do							\
+    {							\
+      do_write_64 (ptr, val);				\
+      ptr += 8;						\
+    }							\
+  while (0)
+
+static uint64_t
+read_size (unsigned char *p, int size)
+{
+  switch (size)
+    {
+    case 1: return read_8 (p);
+    case 2: return read_16 (p);
+    case 4: return read_32 (p);
+    case 8: return read_64 (p);
+    default: abort ();
+    }
+}
+
+static void
+write_size (unsigned char *p, int size, uint64_t val)
+{
+  switch (size)
+    {
+    case 1: write_8 (p, val); break;
+    case 2: write_16 (p, val); break;
+    case 4: write_32 (p, val); break;
+    case 8: write_64 (p, val); break;
+    default: abort ();
+    }
+}
+
+static void
+buf_write_le16 (unsigned char *p, unsigned short v)
+{
+  p[0] = v;
+  p[1] = v >> 8;
+}
+
+static void
+buf_write_be16 (unsigned char *p, unsigned short v)
+{
+  p[1] = v;
+  p[0] = v >> 8;
+}
+
+static void
+buf_write_le32 (unsigned char *p, unsigned int v)
+{
+  p[0] = v;
+  p[1] = v >> 8;
+  p[2] = v >> 16;
+  p[3] = v >> 24;
+}
+
+static void
+buf_write_be32 (unsigned char *p, unsigned int v)
+{
+  p[3] = v;
+  p[2] = v >> 8;
+  p[1] = v >> 16;
+  p[0] = v >> 24;
+}
+
+static void
+buf_write_le64 (unsigned char *data, uint64_t v)
+{
+  buf_write_le32 (data, v);
+  buf_write_le32 (data + 4, v >> 32);
+}
+
+static void
+buf_write_be64 (unsigned char *data, uint64_t v)
+{
+  buf_write_be32 (data, v >> 32);
+  buf_write_be32 (data + 4, v);
+}
+
+/* Return a DW_FORM_* name.  */
+static const char *
+get_DW_FORM_str (unsigned int form)
+{
+  const char *name = get_DW_FORM_name (form);
+  static char buf[9 + 3 * sizeof (int)];
+  if (name)
+    return name;
+  sprintf (buf, "DW_FORM_%u", form);
+  return buf;
+}
+
+/* Return a DW_OP_* name.  */
+static const char *
+get_DW_OP_str (unsigned int op)
+{
+  const char *name = get_DW_OP_name (op);
+  static char buf[7 + 3 * sizeof (int)];
+  if (name)
+    return name;
+  sprintf (buf, "DW_OP_%u", op);
+  return buf;
+}
+
+/* Return a DW_AT_* name.  */
+static const char *
+get_DW_AT_str (unsigned int at)
+{
+  const char *name = get_DW_AT_name (at);
+  static char buf[7 + 3 * sizeof (int)];
+  if (name)
+    return name;
+  sprintf (buf, "DW_AT_%u", at);
+  return buf;
+}
+
+/* Return a DW_UT_* name.  */
+static const char *
+get_DW_UT_str (unsigned int ut)
+{
+  const char *name = get_DW_UT_name (ut);
+  static char buf[7 + 3 * sizeof (int)];
+  if (name)
+    return name;
+  sprintf (buf, "DW_UT_%u", ut);
+  return buf;
+}
+
+/* Retrun a DW_LNCT_* name.  */
+static const char *
+get_DW_LNCT_str (unsigned int lnct)
+{
+  const char *name;
+  static char buf[9 + 3 * sizeof (int)];
+  switch (lnct)
+    {
+    case DW_LNCT_path: name = "DW_LNCT_path"; break;
+    case DW_LNCT_directory_index: name = "DW_LNCT_directory_index"; break;
+    case DW_LNCT_timestamp: name = "DW_LNCT_timestamp"; break;
+    case DW_LNCT_size: name = "DW_LNCT_size"; break;
+    case DW_LNCT_MD5: name = "DW_LNCT_MD5"; break;
+
+    default: name = 0; break;
+    }
+  if (name)
+    return name;
+  sprintf (buf, "DW_LNCT_%u", lnct);
+  return buf;
+}
+
+/* This must match the debug_sections array content
+   below.  */
+enum debug_section_kind
+{
+  DEBUG_INFO,
+  DEBUG_ABBREV,
+  DEBUG_LINE,
+  DEBUG_STR,
+  DEBUG_MACRO,
+  DEBUG_TYPES,
+  DEBUG_ARANGES,
+  DEBUG_PUBNAMES,
+  DEBUG_PUBTYPES,
+  DEBUG_GNU_PUBNAMES,
+  DEBUG_GNU_PUBTYPES,
+  DEBUG_MACINFO,
+  DEBUG_LOC,
+  DEBUG_LOCLISTS,
+  DEBUG_FRAME,
+  DEBUG_RANGES,
+  DEBUG_RNGLISTS,
+  DEBUG_LINE_STR,
+  DEBUG_SUP,
+  DEBUG_GDB_SCRIPTS,
+  GDB_INDEX,
+  GNU_DEBUGALTLINK,
+  SECTION_COUNT,
+  SAVED_SECTIONS = DEBUG_TYPES + 1
+};
+
+/* Details about standard DWARF sections.  */
+static struct
+{
+  const char *name;
+  unsigned char *data;
+  unsigned char *new_data;
+  size_t size;
+  size_t new_size;
+  int sec;
+} debug_sections[] =
+  {
+    { ".debug_info", NULL, NULL, 0, 0, 0 },
+    { ".debug_abbrev", NULL, NULL, 0, 0, 0 },
+    { ".debug_line", NULL, NULL, 0, 0, 0 },
+    { ".debug_str", NULL, NULL, 0, 0, 0 },
+    { ".debug_macro", NULL, NULL, 0, 0, 0 },
+    { ".debug_types", NULL, NULL, 0, 0, 0 },
+    { ".debug_aranges", NULL, NULL, 0, 0, 0 },
+    { ".debug_pubnames", NULL, NULL, 0, 0, 0 },
+    { ".debug_pubtypes", NULL, NULL, 0, 0, 0 },
+    { ".debug_gnu_pubnames", NULL, NULL, 0, 0, 0 },
+    { ".debug_gnu_pubtypes", NULL, NULL, 0, 0, 0 },
+    { ".debug_macinfo", NULL, NULL, 0, 0, 0 },
+    { ".debug_loc", NULL, NULL, 0, 0, 0 },
+    { ".debug_loclists", NULL, NULL, 0, 0, 0 },
+    { ".debug_frame", NULL, NULL, 0, 0, 0 },
+    { ".debug_ranges", NULL, NULL, 0, 0, 0 },
+    { ".debug_rnglists", NULL, NULL, 0, 0, 0 },
+    { ".debug_line_str", NULL, NULL, 0, 0, 0 },
+    { ".debug_sup", NULL, NULL, 0, 0, 0 },
+    { ".debug_gdb_scripts", NULL, NULL, 0, 0, 0 },
+    { ".gdb_index", NULL, NULL, 0, 0, 0 },
+    { ".gnu_debugaltlink", NULL, NULL, 0, 0, 0 },
+    { NULL, NULL, NULL, 0, 0, 0 }
+  };
+
+/* Copies of .new_data fields during write_multifile.  */
+static unsigned char *saved_new_data[SAVED_SECTIONS];
+/* Copies of .new_size fields during write_multifile.  */
+static size_t saved_new_size[SAVED_SECTIONS];
+
+/* Copies of .data fields after read_multifile.  */
+static unsigned char *alt_data[SAVED_SECTIONS];
+/* Copies of .size fields after read_multifile.  */
+static size_t alt_size[SAVED_SECTIONS];
+
+/* How many bytes of each of /tmp/dwz.debug_*.XXXXXX have we written
+   already.  */
+static unsigned int multi_info_off, multi_abbrev_off;
+static unsigned int multi_line_off, multi_str_off;
+static unsigned int multi_macro_off;
+/* And corresponding file descriptors.  */
+static int multi_info_fd = -1, multi_abbrev_fd = -1;
+static int multi_line_fd = -1, multi_str_fd = -1;
+static int multi_macro_fd = -1;
+
+/* Copy of one of the input file's ehdr.  */
+static GElf_Ehdr multi_ehdr;
+
+/* Pointer size of all debug info sources accumulated during
+   write_multifile.  */
+static int multi_ptr_size;
+/* And their endianity.  */
+static int multi_endian;
+/* Highest .gdb_index version seen.  */
+static unsigned int multi_gdb_index_ver;
+
+enum multifile_mode_kind
+{
+  MULTIFILE_MODE_WR = 1,
+  MULTIFILE_MODE_OP = 2,
+  MULTIFILE_MODE_RD = 4,
+  MULTIFILE_MODE_FI = 8,
+  MULTIFILE_MODE_LOW_MEM = 16
+};
+
+/* True while in write_multifile.  */
+#define wr_multifile (multifile_mode & MULTIFILE_MODE_WR)
+
+/* True while in optimize_multifile.  */
+#define op_multifile (multifile_mode & MULTIFILE_MODE_OP)
+
+/* True while in read_multifile.  */
+#define rd_multifile (multifile_mode & MULTIFILE_MODE_RD)
+
+/* True while in finalize_multifile.  */
+#define fi_multifile (multifile_mode & MULTIFILE_MODE_FI)
+
+/* True if running in low_mem mode.  */
+#define low_mem (multifile_mode & MULTIFILE_MODE_LOW_MEM)
+
+/* SHA1 checksum (build-id) of the common file.  */
+static unsigned char multifile_sha1[0x14];
+
+/* A single attribute in abbreviations.  */
+struct abbrev_attr
+{
+  /* DW_AT_* attribute code.  */
+  unsigned int attr;
+  /* DW_FORM_* form code.  */
+  unsigned int form;
+};
+
+/* Internal structure for .debug_abbrev entries.  */
+struct abbrev_tag
+{
+  /* Abbreviation number.  */
+  unsigned int entry;
+  /* Hash value, in first abbrev hash tables it is
+     the same as entry, in cu->cu_new_abbrev hash tables
+     iterative hash of all the relevant values.  */
+  hashval_t hash;
+  /* DW_TAG_* code.  */
+  unsigned int tag;
+  /* Number of attributes.  */
+  unsigned int nattr;
+  /* How many DIEs refer to this abbreviation (unused
+     in first abbrev hash tables).  */
+  unsigned int nusers;
+  /* True if DIEs with this abbreviation have children.  */
+  bool children;
+  /* True if any typed DWARF opcodes refer to this.  */
+  bool op_type_referenced;
+  /* The values of DW_FORM_implicit_const attribute forms.  */
+  int64_t *values;
+  /* Attribute/form pairs.  */
+  struct abbrev_attr attr[0];
+};
+
+typedef struct dw_die *dw_die_ref;
+typedef struct dw_cu *dw_cu_ref;
+struct import_cu;
+
+/* An entry from .debug_line file table.  */
+struct dw_file
+{
+  char *dir;
+  char *file;
+  uint64_t time, size;
+  unsigned int file_angle_brackets_encapsulated_no_slash : 1;
+};
+
+/* Internal representation of a compilation (or partial)
+   unit.  */
+struct dw_cu
+{
+  /* Cached entries from .debug_line file table.  */
+  struct dw_file *cu_files;
+  unsigned int cu_nfiles;
+  /* Kind of CU, normal (present in .debug_info), newly created
+     partial unit, .debug_types unit or .debug_info partial unit
+     from the common file.  */
+  enum { CU_NORMAL, CU_PU, CU_TYPES, CU_ALT } cu_kind;
+  /* CUs linked from first_cu through this chain.  */
+  dw_cu_ref cu_next;
+  /* Offset in original .debug_info if CU_NORMAL or .debug_types
+     if CU_TYPES, otherwise a unique index of the newly created
+     partial CU.  */
+  unsigned int cu_offset;
+  /* DWARF version of the CU.  */
+  unsigned int cu_version;
+  /* Cached DW_AT_comp_dir value from DW_TAG_*_unit cu_die,
+     or NULL if that attribute is not present.  */
+  char *cu_comp_dir;
+  /* Pointer to the DW_TAG_*_unit inside of the .debug_info
+     chunk.  */
+  dw_die_ref cu_die;
+  /* The original abbreviation hash table.  */
+  htab_t cu_abbrev;
+  /* New abbreviation hash table.  */
+  htab_t cu_new_abbrev;
+  union dw_cu_u1
+    {
+      /* Pointer to another struct dw_cu that owns
+	 cu_new_abbrev for this CU.  */
+      dw_cu_ref cu_new_abbrev_owner;
+      /* Pointer used during create_import_tree.  */
+      struct import_cu *cu_icu;
+    } u1;
+  union dw_cu_u2
+    {
+      /* Offset into the new .debug_abbrev section.  */
+      unsigned int cu_new_abbrev_offset;
+      /* Highest ->entry value in the new abbrev table
+	 For abbrevs computed by this tool it is always
+	 equal to the number of abbreviations, but if
+	 abbrevs are read for .debug_types section which
+	 is not rewritten, there might be holes.  */
+      unsigned int cu_largest_entry;
+    } u2;
+  /* Offset into the new .debug_info section.  */
+  unsigned int cu_new_offset;
+  /* When op_multifile, record which object this came from here,
+     otherwise it is the index of the CU.  */
+  unsigned int cu_chunk;
+  /* Form chosen for intra-cu references.  */
+  enum dwarf_form cu_intracu_form;
+  /* Intracusize argument to init_new_die_offsets.  Set in compute_abbrevs,
+     used in recompute_abbrevs.  */
+  unsigned int initial_intracusize;
+  enum dwarf_source_language lang;
+};
+
+/* Internal representation of a debugging information entry (DIE).
+   This structure should be kept as small as possible,
+   there are .debug_info sections with tens of millions of DIEs
+   in them and this structure is allocated for each of them.  */
+struct dw_die
+{
+  /* Offset in old .debug_info from the start of the .debug_info section,
+     -1U for newly created DIEs.  */
+  unsigned int die_offset;
+  /* Cached copy of die_abbrev->tag.  */
+  enum dwarf_tag die_tag : 16;
+  /* State of checksum computation.  Not computed yet, computed and
+     suitable for moving into partial units, currently being computed
+     and finally determined unsuitable for moving into partial units.  */
+  enum { CK_UNKNOWN, CK_KNOWN, CK_BEING_COMPUTED, CK_BAD } die_ck_state : 2;
+  /* Set if any DW_OP_call2 opcode refers to this DIE.  */
+  unsigned int die_op_call2_referenced : 1;
+  /* Set if any DW_OP_GNU_{{regval,deref,const}_type,convert,reinterpret}
+     opcode refers to this DIE.  Only DW_TAG_base_type DIEs should be
+     referenced.  As those opcodes refer to them using uleb128, we need to try
+     hard to have those DIEs with low enough offsets that the uleb128 will
+     fit.  */
+  unsigned int die_op_type_referenced : 1;
+  /* Set in DW_TAG_namespace or DW_TAG_module with DW_AT_name that is
+     either a child of DW_TAG_*_unit, or a child of another
+     die_named_namespace DIE.  */
+  unsigned int die_named_namespace : 1;
+  /* Set if u.p1.die_ref_hash is valid.  */
+  unsigned int die_ref_hash_computed : 1;
+  /* Set if die_dup and die_nextdup fields are after this structure.
+     True for DW_TAG_*_unit DIEs, die_named_namespace DIEs and their
+     immediate children.  */
+  unsigned int die_toplevel : 1;
+  /* Set if we want to remove this DIE from its containing CU.  */
+  unsigned int die_remove : 1;
+  /* Set if DIE is unsuitable for moving into alternate .debug_info.  */
+  unsigned int die_no_multifile : 1;
+  /* Set if DIE is referenced using DW_FORM_ref*.  So far only used during
+     optimize_multifile and low_mem.  */
+  unsigned int die_referenced : 1;
+  /* Set if DIE is referenced using DW_FORM_ref_addr.  So far used only
+     during low_mem.  */
+  unsigned int die_intercu_referenced : 1;
+  /* Set if DIE has its children collapsed.  Only used during
+     optimize_multifile.  */
+  unsigned int die_collapsed_children : 1;
+  /* Set on collapsed child DIE that is referenced.  In that case, die_tag
+     is reused for die_enter difference from parent and no fields after
+     die_parent are allocated.  */
+  unsigned int die_collapsed_child : 1;
+  /* Set if die_parent field is reused for struct dw_cu pointer.  */
+  unsigned int die_root : 1;
+  /* State for ODR optimization.  */
+  enum { ODR_UNKNOWN, ODR_NONE, ODR_DEF, ODR_DECL } die_odr_state : 2;
+  /* Tree pointer to parent.  */
+  dw_die_ref die_parent;
+
+  /* The remaining fields are present only if die_collapsed_child is
+     0.  */
+
+  /* Tree pointers, to first child and pointer to next sibling.  */
+  dw_die_ref die_child, die_sib;
+  /* Pointer to the old .debug_abbrev entry's internal representation.  */
+  struct abbrev_tag *die_abbrev;
+  /* Size of the DIE (abbrev number + attributes), not including children.
+     In later phases this holds the new size as opposed to the old one.  */
+  unsigned int die_size;
+  /* Index into the dw_die_ref vector used in checksum_ref_die function.
+     While this is only phase 1 field, we get better packing by having it
+     here instead of u.p1.  */
+  unsigned int die_ref_seen;
+  union dw_die_phase
+    {
+      /* Fields used in the first phase (read_debug_info and partition_dups
+	 and functions they call).  */
+      struct dw_die_p1
+	{
+	  /* Iterative hash value of the tag, attributes other than
+	     references or DW_FORM_ref_addr references or references
+	     within the subtree of ultimate parent's die_toplevel DIE's
+	     children.  Computed by checksum_die function.  */
+	  hashval_t die_hash;
+	  /* Iterative hash of other references.  Computed by
+	     checksum_ref_die function.  */
+	  hashval_t die_ref_hash;
+	  /* For ODR phase 1, we change die_hash for ODR_DEF and ODR_DECL DIEs
+	     to only hash in the tag and the name, to be able to construct
+	     maximal duplicate chains.  But during ODR phase 2, we want to
+	     compare ODR_DEF DIEs in the normal way, for which we need the
+	     unchanged die_hash, which we store here in die_hash2.  */
+	  hashval_t die_hash2;
+	  /* Tick count of entering and leaving a DIE during depth first
+	     traversal of the CU, used to quickly find if a subtree is
+	     referenced.  */
+	  unsigned int die_enter, die_exit;
+	} p1;
+      /* Fields used only after the first phase (from compute_abbrevs
+	 till the end).  */
+      struct dw_die_p2
+	{
+	  /* Pointer to internal representation of new .debug_abbrev
+	     entry for this DIE.  */
+	  struct abbrev_tag *die_new_abbrev;
+	  /* Offset within the new .debug_info CU.  Unlike die_offset
+	     this one is CU relative, so die_cu (die)->cu_new_offset needs
+	     to be added to it to get .debug_info offset.  */
+	  unsigned int die_new_offset;
+	  /* Used during compute_abbrevs DW_FORM_ref_udata optimization.  */
+	  unsigned int die_intracu_udata_size;
+	} p2;
+     } u;
+
+  /* The remaining fields are present only if die_toplevel is
+     1.  */
+
+  /* Pointer to a duplicate DIE.  */
+  dw_die_ref die_dup;
+  /* Chain of duplicate DIEs.  If die_dup is NULL, but die_nextdup
+     is non-NULL, this is the reference DIE of the duplicates.
+     All DIEs in the die->nextdup linked list have die_dup pointing
+     to this node.  The reference DIE is initially just a DIE in the
+     lowest CU that has the matching DIE, later on it is a DIE in
+     the newly created partial unit CU.  */
+  dw_die_ref die_nextdup;
+};
+
+#include "iterators.h"
+
+/* Return CU structure pointer for a DIE.  In order to save memory,
+   individual DIEs don't have a dw_cu_ref field, and the pointer can
+   be only found by overriding the die_parent pointer in a
+   DW_TAG_{compile,partial}_unit descriptor, which has no parent.  */
+static inline dw_cu_ref
+die_cu (dw_die_ref die)
+{
+  while (!die->die_root)
+    die = die->die_parent;
+  return (dw_cu_ref) die->die_parent;
+}
+
+/* Given a toplevel die DIE, return the first (that is, the reference die) in
+   the duplicate chain.  */
+#define first_dup(die)				\
+  (die->die_dup					\
+   ? die->die_dup				\
+   : (die->die_nextdup				\
+      ? die					\
+      : NULL))
+
+/* Safe variant that check die_toplevel.  Can't be used on LHS.  */
+#define die_safe_dup(die) \
+  ((die)->die_toplevel ? (die)->die_dup : (dw_die_ref) NULL)
+#define die_safe_nextdup(die) \
+  ((die)->die_toplevel ? (die)->die_nextdup : (dw_die_ref) NULL)
+
+ALIGN_STRUCT (abbrev_tag)
+ALIGN_STRUCT (dw_file)
+ALIGN_STRUCT (dw_cu)
+ALIGN_STRUCT (dw_die)
+
+
+/* After read_multifile, pool variable is moved over to this variable
+   as the pool from read_multifile needs to be around for subsequent dwz
+   calls.  Freed only during the final cleanup at the very end.  */
+static unsigned char *alt_pool;
+
+static struct abbrev_tag *
+pool_clone_abbrev (struct abbrev_tag *t)
+{
+  struct abbrev_tag *newt;
+  size_t newt_size;
+  unsigned nvalue = 0;
+  if (t->values != NULL)
+    {
+      unsigned i;
+      for (i = 0; i < t->nattr; i++)
+	if (t->attr[i].form == DW_FORM_implicit_const)
+	  nvalue = i + 1;
+    }
+  newt_size = (sizeof (*newt)
+	       + t->nattr * sizeof (struct abbrev_attr)
+	       + nvalue * sizeof (int64_t));
+  newt = pool_alloc (abbrev_tag, newt_size);
+  memcpy (newt, t, newt_size - (nvalue * sizeof (int64_t)));
+  if (nvalue == 0)
+    newt->values = NULL;
+  else
+    {
+      newt->values = (int64_t *) &newt->attr[newt->nattr];
+      memcpy (newt->values, t->values, nvalue * sizeof (int64_t));
+    }
+  return newt;
+}
+
+/* Hash function in first abbrev hash table as well as cu->cu_new_abbrev
+   htab.  */
+static hashval_t
+abbrev_hash (const void *p)
+{
+  struct abbrev_tag *t = (struct abbrev_tag *)p;
+
+  return t->hash;
+}
+
+/* Equality function in first abbrev htab.  */
+static int
+abbrev_eq (const void *p, const void *q)
+{
+  struct abbrev_tag *t1 = (struct abbrev_tag *)p;
+  struct abbrev_tag *t2 = (struct abbrev_tag *)q;
+
+  return t1->entry == t2->entry;
+}
+
+/* Equality function in cu->cu_new_abbrev htab.  */
+static int
+abbrev_eq2 (const void *p, const void *q)
+{
+  struct abbrev_tag *t1 = (struct abbrev_tag *)p;
+  struct abbrev_tag *t2 = (struct abbrev_tag *)q;
+  unsigned int i;
+
+  if (t1->hash != t2->hash
+      || t1->tag != t2->tag
+      || t1->nattr != t2->nattr
+      || t1->children != t2->children)
+    return 0;
+  for (i = 0; i < t1->nattr; i++)
+    if (t1->attr[i].attr != t2->attr[i].attr
+	|| t1->attr[i].form != t2->attr[i].form
+	|| (t1->attr[i].form == DW_FORM_implicit_const
+	    && t1->values[i] != t2->values[i]))
+      return 0;
+  return 1;
+}
+
+/* Helper function to compute abbrev entry iterative hash value.  */
+static void
+compute_abbrev_hash (struct abbrev_tag *t)
+{
+  unsigned int i;
+
+  hash_init_state ();
+  hash_update_state_object (t->tag);
+  hash_update_state_object (t->nattr);
+  hash_update_state_object (t->children);
+  for (i = 0; i < t->nattr; i++)
+    {
+      hash_update_state_object (t->attr[i].attr);
+      hash_update_state_object (t->attr[i].form);
+      if (t->attr[i].form == DW_FORM_implicit_const)
+	hash_update_state_object (t->values[i]);
+    }
+  t->hash = hash_digest ();
+}
+
+/* Maximum number of attributes in a DIE.  */
+static unsigned int max_nattr;
+
+/* Parse a .debug_abbrev entry at PTR.  */
+static htab_t
+read_abbrev (DSO *dso, unsigned char *ptr)
+{
+  htab_t h;
+  unsigned int attr, form;
+  struct abbrev_tag *t;
+  void **slot;
+
+  h = htab_try_create (50, abbrev_hash, abbrev_eq, NULL);
+  if (h == NULL)
+    dwz_oom ();
+
+  while ((attr = read_uleb128 (ptr)) != 0)
+    {
+      int highest_implicit_value_ndx = -1;
+      unsigned int nattr = 0;
+      unsigned char *p = ptr;
+
+      skip_leb128 (p);
+      p++;
+      while (read_uleb128 (p) != 0)
+	{
+	  nattr++;
+	  form = read_uleb128 (p);
+	  if (form == DW_FORM_implicit_const)
+	    {
+	      skip_leb128 (p);
+	      highest_implicit_value_ndx = nattr - 1;
+	    }
+	  else if (form == 2
+	      || (form > DW_FORM_flag_present
+		  && !(form == DW_FORM_ref_sig8
+		       || form == DW_FORM_data16
+		       || form == DW_FORM_line_strp)))
+	    {
+	      error (0, 0, "%s: Unknown DWARF %s at .debug_abbrev [%zd]",
+		     dso->filename, get_DW_FORM_str (form),
+		     p - debug_sections[DEBUG_ABBREV].data);
+	      htab_delete (h);
+	      return NULL;
+	    }
+	}
+      if (read_uleb128 (p) != 0)
+	{
+	  error (0, 0, "%s: DWARF abbreviation does not end with 2 zeros",
+		 dso->filename);
+	  htab_delete (h);
+	  return NULL;
+	}
+
+      t = pool_alloc (abbrev_tag,
+		      sizeof (*t) + nattr * sizeof (struct abbrev_attr)
+		      + sizeof (int64_t) * (highest_implicit_value_ndx + 1));
+      t->entry = attr;
+      t->hash = attr;
+      t->nattr = nattr;
+      t->nusers = 0;
+      t->tag = read_uleb128 (ptr);
+      t->children = *ptr++ == DW_CHILDREN_yes;
+      t->op_type_referenced = false;
+      t->values = (highest_implicit_value_ndx >= 0
+		   ? (int64_t *) &t->attr[nattr] : NULL);
+      nattr = 0;
+      while ((attr = read_uleb128 (ptr)) != 0)
+	{
+	  form = read_uleb128 (ptr);
+	  if (form == DW_FORM_implicit_const)
+	    t->values[nattr] = read_sleb128 (ptr);
+	  t->attr[nattr].attr = attr;
+	  t->attr[nattr++].form = form;
+	}
+      skip_leb128 (ptr);
+      if (t->nattr > max_nattr)
+	max_nattr = t->nattr;
+      slot = htab_find_slot_with_hash (h, t, t->hash, INSERT);
+      if (slot == NULL)
+	{
+	  htab_delete (h);
+	  dwz_oom ();
+	}
+      if (*slot != NULL)
+	{
+	  error (0, 0, "%s: Duplicate DWARF abbreviation %d", dso->filename,
+		 t->entry);
+	  htab_delete (h);
+	  return NULL;
+	}
+      *slot = t;
+    }
+
+  return h;
+}
+
+/* For a die attribute with form FORM starting at PTR, with the die in CU,
+   return the pointer after the attribute, assuming FORM is not
+   dw_form_indirect.  */
+static inline unsigned char * FORCE_INLINE
+skip_attr_no_dw_form_indirect (unsigned int cu_version, uint32_t form,
+			       unsigned char *ptr)
+{
+  size_t len = 0;
+
+  switch (form)
+    {
+    case DW_FORM_ref_addr:
+      ptr += cu_version == 2 ? ptr_size : 4;
+      break;
+    case DW_FORM_addr:
+      ptr += ptr_size;
+      break;
+    case DW_FORM_flag_present:
+    case DW_FORM_implicit_const:
+      break;
+    case DW_FORM_ref1:
+    case DW_FORM_flag:
+    case DW_FORM_data1:
+      ++ptr;
+      break;
+    case DW_FORM_ref2:
+    case DW_FORM_data2:
+      ptr += 2;
+      break;
+    case DW_FORM_ref4:
+    case DW_FORM_data4:
+    case DW_FORM_sec_offset:
+    case DW_FORM_strp:
+    case DW_FORM_line_strp:
+      ptr += 4;
+      break;
+    case DW_FORM_ref8:
+    case DW_FORM_data8:
+    case DW_FORM_ref_sig8:
+      ptr += 8;
+      break;
+    case DW_FORM_data16:
+      ptr += 16;
+      break;
+    case DW_FORM_sdata:
+    case DW_FORM_ref_udata:
+    case DW_FORM_udata:
+      skip_leb128 (ptr);
+      break;
+    case DW_FORM_string:
+      ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+      break;
+    case DW_FORM_indirect:
+      abort ();
+    case DW_FORM_block1:
+      len = *ptr++;
+      break;
+    case DW_FORM_block2:
+      len = read_16 (ptr);
+      form = DW_FORM_block1;
+      break;
+    case DW_FORM_block4:
+      len = read_32 (ptr);
+      form = DW_FORM_block1;
+      break;
+    case DW_FORM_block:
+    case DW_FORM_exprloc:
+      len = read_uleb128 (ptr);
+      form = DW_FORM_block1;
+      break;
+    default:
+      abort ();
+    }
+
+  if (form == DW_FORM_block1)
+    ptr += len;
+
+  return ptr;
+}
+
+/* Read the directory and file table from .debug_line offset OFF,
+   record it in CU.  */
+static int
+read_debug_line (DSO *dso, dw_cu_ref cu, uint32_t off)
+{
+  unsigned char *ptr = debug_sections[DEBUG_LINE].data, *dir, *file;
+  unsigned char **dirt;
+  unsigned char *endsec = ptr + debug_sections[DEBUG_LINE].size;
+  unsigned char *endcu, *endprol;
+  unsigned char opcode_base;
+  unsigned int culen;
+  uint32_t value, version, ndirs, nfiles, dirt_cnt, file_cnt;
+  /* DWARF5 has a dynamic table of elements in possible different
+     forms.  But we are only interested in the known elements (path,
+     dir index, time, size and possibly later md5).  */
+  unsigned char n, nelems = 0;
+  int path_ndx = -1;
+  int dir_ndx = -1;
+  int time_ndx = -1;
+  int size_ndx = -1;
+  uint16_t elems[256];
+
+  if (off >= debug_sections[DEBUG_LINE].size - 4)
+    {
+      error (0, 0, "%s: .debug_line reference above end of section",
+	     dso->filename);
+      return 1;
+    }
+
+  ptr += off;
+
+  endcu = ptr + 4;
+  culen = read_32 (ptr);
+  if (culen >= 0xfffffff0)
+    {
+      error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+      return 1;
+    }
+  endcu += culen;
+
+  if (endcu > endsec)
+    {
+      error (0, 0, "%s: .debug_line CU does not fit into section",
+	     dso->filename);
+      return 1;
+    }
+
+  value = read_16 (ptr);
+  if (value < 2 || value > 5)
+    {
+      error (0, 0, "%s: DWARF version %d in .debug_line unhandled",
+	     dso->filename, value);
+      return 1;
+    }
+  version = value;
+
+  if (version < lowest_line_version)
+    lowest_line_version = version;
+
+  if (version >= 5)
+    {
+      int addr_size, seg_size;
+      if (ptr + 2 > endcu)
+	{
+	  error (0, 0, "%s: .debug_line header too short", dso->filename);
+	  return 1;
+	}
+      addr_size = *ptr++;
+      seg_size = *ptr++;
+      if (addr_size != ptr_size)
+	{
+	  error (0, 0, "%s: .debug_line address size differs from CU ptr size",
+		 dso->filename);
+	  return 1;
+	}
+      if (seg_size != 0)
+	{
+	  error (0, 0, "%s: .debug_line non-zero segment selector size",
+		 dso->filename);
+	  return 1;
+	}
+    }
+
+  endprol = ptr + 4;
+  endprol += read_32 (ptr);
+  if (endprol > endcu)
+    {
+      error (0, 0, "%s: .debug_line CU prologue does not fit into CU",
+	     dso->filename);
+      return 1;
+    }
+
+  opcode_base = ptr[4 + (version >= 4)];
+  ptr = dir = ptr + 4 + (version >= 4) + opcode_base;
+
+  /* dir table: */
+  if (version < 5)
+    {
+      value = 1;
+      while (*ptr != 0)
+	{
+	  ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+	  ++value;
+	}
+      ndirs = value;
+    }
+  else
+    {
+      nelems = *ptr++;
+      for (n = 0; n < nelems; n++)
+	{
+	  uint16_t lnct = read_uleb128 (ptr);
+	  uint16_t form = read_uleb128 (ptr);
+	  if (lnct == DW_LNCT_path)
+	    {
+	      if (path_ndx != -1)
+		{
+		  error (0, 0, "%s: .debug_line duplicate dir path elements",
+			 dso->filename);
+		  return 1;
+		}
+	      path_ndx = n;
+	    }
+	  else
+	    {
+	      error (0, 0, "%s: .debug_line unhandled dir element %s",
+		     dso->filename, get_DW_LNCT_str (lnct));
+	      return 1;
+	    }
+
+	  if (form != DW_FORM_string
+	      && form != DW_FORM_strp
+	      && form != DW_FORM_line_strp)
+	    {
+	      error (0, 0, "%s: .debug_line unhandled form %s for dir path",
+		     dso->filename, get_DW_FORM_str (form));
+	      return 1;
+	    }
+
+	  elems[n] = form;
+	}
+
+      ndirs = read_uleb128 (ptr);
+    }
+
+  dirt = (unsigned char **) alloca (ndirs * sizeof (unsigned char *));
+  if (version < 5)
+    {
+      dirt[0] = NULL;
+      dirt_cnt = 1;
+      ptr = dir;
+      while (*ptr != 0)
+	{
+	  dirt[dirt_cnt++] = ptr;
+	  ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+	}
+      ptr++;
+    }
+  else
+    {
+      for (dirt_cnt = 0; dirt_cnt < ndirs; dirt_cnt++)
+	{
+	  for (n = 0; n < nelems; n++)
+	    {
+	      uint32_t form = elems[n];
+	      if (n == path_ndx)
+		{
+		  unsigned char *d;
+		  switch (form)
+		    {
+		    case DW_FORM_string:
+		      d = (unsigned char *) ptr;
+		      break;
+		    case DW_FORM_strp:
+		      {
+			unsigned int strp = do_read_32 (ptr);
+			if (strp >= debug_sections[DEBUG_STR].size)
+			  d = NULL;
+			else
+			  d = ((unsigned char *)
+			       debug_sections[DEBUG_STR].data
+			       + strp);
+		      }
+		      break;
+		    case DW_FORM_line_strp:
+		      {
+			unsigned int line_strp = do_read_32 (ptr);
+			if (line_strp >= debug_sections[DEBUG_LINE_STR].size)
+			  d = NULL;
+			else
+			  d = ((unsigned char *)
+			       debug_sections[DEBUG_LINE_STR].data
+			       + line_strp);
+		      }
+		      break;
+		    default:
+		      d = NULL;
+		      break;
+		    }
+
+		  if (d == NULL)
+		    {
+		      error (0, 0, "%s: .debug_line bad dir path",
+			     dso->filename);
+		      return 1;
+		    }
+
+		  /* Note we do this even for the zero entry, which is
+		     marked as NULL for pre-DWARF5 line tables.  This
+		     is important for when we merge file entries
+		     together for a multifile because the zero dir
+		     entry could differ.  It is should be equivalent
+		     to the CU DIE comp_dir attribute, but we don't
+		     track that all CUs referring to the (same) line
+		     table share identical an DW_AT_comp_dir value.  */
+		  dirt[dirt_cnt] = d;
+		}
+	      ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+	    }
+	}
+    }
+
+  /* file table: */
+  file = ptr;
+  if (version < 5)
+    {
+      file_cnt = 0;
+      while (*ptr != 0)
+	{
+	  ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+	  value = read_uleb128 (ptr);
+
+	  if (value >= dirt_cnt)
+	    {
+	      error (0, 0, "%s: Wrong directory table index %u",
+		     dso->filename, value);
+	      return 1;
+	    }
+
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  file_cnt++;
+	}
+      nfiles = file_cnt;
+    }
+  else
+    {
+      nelems = *ptr++;
+      path_ndx = -1;
+      for (n = 0; n < nelems; n++)
+	{
+	  uint16_t lnct = read_uleb128 (ptr);
+	  uint16_t form = read_uleb128 (ptr);
+	  switch (lnct)
+	    {
+	    case DW_LNCT_path:
+	      if (path_ndx != -1)
+		{
+		  error (0, 0,
+			 "%s: .debug_line duplicate file path elements",
+			 dso->filename);
+		  return 1;
+		}
+	      path_ndx = n;
+
+	      /* Currently we only handle two string form which always
+		 stay... */
+	      if (form != DW_FORM_string && form != DW_FORM_line_strp)
+		{
+		  error (0, 0,
+			 "%s: .debug_line unhandled form %s for file path",
+			 dso->filename, get_DW_FORM_str (form));
+		  return 1;
+		}
+	      break;
+
+	    case DW_LNCT_directory_index:
+	      if (dir_ndx != -1)
+		{
+		  error (0, 0,
+			 "%s: .debug_line duplicate file dir elements",
+			 dso->filename);
+		  return 1;
+		}
+	      dir_ndx = n;
+
+	      if (form != DW_FORM_data1
+		  && form != DW_FORM_data2
+		  && form != DW_FORM_udata)
+		{
+		  error (0, 0,
+			 "%s: .debug_line unhandled form %s for dir index",
+			 dso->filename, get_DW_FORM_str (form));
+		  return 1;
+		}
+	      break;
+
+	    case DW_LNCT_timestamp:
+	      if (time_ndx != -1)
+		{
+		  error (0, 0,
+			 "%s: .debug_line duplicate file time elements",
+			 dso->filename);
+		  return 1;
+		}
+	      time_ndx = n;
+
+	      if (form != DW_FORM_udata
+		  && form != DW_FORM_data4
+		  && form != DW_FORM_data8)
+		{
+		  error (0, 0,
+			 "%s: .debug_line unhandled form %s for file time",
+			 dso->filename, get_DW_FORM_str (form));
+		  return 1;
+		}
+	      break;
+
+	    case DW_LNCT_size:
+	      if (size_ndx != -1)
+		{
+		  error (0, 0,
+			 "%s: .debug_line duplicate file size elements",
+			 dso->filename);
+		  return 1;
+		}
+	      size_ndx = n;
+
+	      if (form != DW_FORM_udata
+		  && form != DW_FORM_data1
+		  && form != DW_FORM_data2
+		  && form != DW_FORM_data4
+		  && form != DW_FORM_data8)
+		{
+		  error (0, 0,
+			 "%s: .debug_line unhandled form %s for file size",
+			 dso->filename, get_DW_FORM_str (form));
+		  return 1;
+		}
+	      break;
+
+	    default:
+	      error (0, 0, "%s: .debug_line unhandled file element %s",
+		     dso->filename, get_DW_LNCT_str (lnct));
+	      return 1;
+	    }
+	  elems[n] = form;
+	}
+
+      nfiles = read_uleb128 (ptr);
+      if (nfiles > 0)
+       nfiles--; /* We will skip the first (zero) entry.  */
+    }
+
+  cu->cu_nfiles = nfiles;
+  cu->cu_files = pool_alloc (dw_file, nfiles * sizeof (struct dw_file));
+  memset (cu->cu_files, 0, nfiles * sizeof (struct dw_file));
+
+  if (version < 5)
+    ptr = file;
+
+  for (file_cnt = 0; file_cnt < nfiles; file_cnt++)
+    {
+      char *f = NULL;
+      char *end = NULL;
+      uint32_t d = 0;
+      uint64_t time = 0;
+      uint64_t size = 0;
+      if (version < 5)
+	{
+	  f = (char *) ptr;
+	  ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+	  end = (char *) ptr;
+	  d = read_uleb128 (ptr);
+	  time = read_uleb128 (ptr);
+	  size = read_uleb128 (ptr);
+	}
+      else
+	{
+	  /* Skip zero entry.  */
+	  if (file_cnt == 0)
+	    for (n = 0; n < nelems; n++)
+	      ptr = skip_attr_no_dw_form_indirect (cu->cu_version,
+						   elems[n], ptr);
+
+	  for (n = 0; n < nelems; n++)
+	    {
+	      uint32_t form = elems[n];
+	      if (n == path_ndx)
+		{
+		  switch (form)
+		    {
+		    case DW_FORM_string:
+		      f = (char *) ptr;
+		      end = strchr ((char *)ptr, 0) + 1;
+		      break;
+		    case DW_FORM_strp:
+		      {
+			unsigned int strp = do_read_32 (ptr);
+			if (strp >= debug_sections[DEBUG_STR].size)
+			  f = NULL;
+			else
+			  {
+			    f = ((char *) debug_sections[DEBUG_STR].data
+				 + strp);
+			    end = f + strlen (f) + 1;
+			  }
+		      }
+		      break;
+		    case DW_FORM_line_strp:
+		      {
+			unsigned int line_strp = do_read_32 (ptr);
+			if (line_strp >= debug_sections[DEBUG_LINE_STR].size)
+			  f = NULL;
+			else
+			  {
+			    f = ((char *) debug_sections[DEBUG_LINE_STR].data
+				 + line_strp);
+			    end = f + strlen (f) + 1;
+			  }
+		      }
+		      break;
+		    default:
+		      f = NULL;
+		      break;
+		    }
+
+		  if (f == NULL)
+		    {
+		      error (0, 0, "%s: .debug_line bad file path",
+			     dso->filename);
+		      return 1;
+		    }
+		}
+	      else if (n == dir_ndx)
+		{
+		  switch (form)
+		    {
+		    case DW_FORM_data1:
+		      d = *ptr;
+		      break;
+		    case DW_FORM_data2:
+		      d = do_read_16 (ptr);
+		      break;
+		    case DW_FORM_udata:
+		      {
+			unsigned char *p = ptr;
+			d = read_uleb128 (p);
+		      }
+		      break;
+		    }
+		}
+	      ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+	    }
+	}
+
+      cu->cu_files[file_cnt].file = f;
+      if (d >= dirt_cnt)
+	{
+	  error (0, 0, "%s: Wrong directory table index %u",
+		 dso->filename, value);
+	  return 1;
+	}
+
+      cu->cu_files[file_cnt].dir = (char *) dirt[d];
+      cu->cu_files[file_cnt].time = time;
+      cu->cu_files[file_cnt].size = size;
+      size_t file_len = (char *) end - f;
+      size_t strlen_file = file_len - 1;
+      bool file_has_slash = false;
+      if (cu->cu_files[file_cnt].file[0] != '/'
+	  && cu->cu_files[file_cnt].dir != NULL)
+	{
+	  size_t dir_len = strlen (cu->cu_files[file_cnt].dir);
+	  if (dir_len)
+	    {
+	      obstack_grow (&ob, cu->cu_files[file_cnt].dir,
+			    dir_len);
+	      strlen_file += dir_len;
+	      if (cu->cu_files[file_cnt].dir[dir_len - 1] != '/')
+		{
+		  obstack_1grow (&ob, '/');
+		  strlen_file++;
+		}
+	      file_has_slash = true;
+	      obstack_grow (&ob, cu->cu_files[file_cnt].file,
+			    file_len);
+	      cu->cu_files[file_cnt].file
+		= (char *) obstack_finish (&ob);
+	      cu->cu_files[file_cnt].dir = NULL;
+	    }
+	}
+      cu->cu_files[file_cnt].file_angle_brackets_encapsulated_no_slash
+	= (!file_has_slash
+	   && cu->cu_files[file_cnt].file[0] == '<'
+	   && cu->cu_files[file_cnt].file[strlen_file - 1] == '>'
+	   && strchr (cu->cu_files[file_cnt].file, '/') == NULL);
+    }
+
+  return 0;
+}
+
+/* Estimate the amount of DIEs in the .debug_info section, based on the size
+   of that section.  */
+static unsigned int
+estimate_nr_dies (void)
+{
+  unsigned int average_die_size = 11;
+  unsigned int nr_dies = debug_sections[DEBUG_INFO].size / average_die_size;
+  return nr_dies;
+}
+
+static size_t
+emulate_htab (size_t initial, size_t final_nr_elements)
+{
+  size_t size = initial;
+
+  /* Emulate creation.  */
+  size = higher_prime_number (size);
+
+  /* Emulate growing till htab contains find_nr_elements.  */
+  while (1)
+    {
+      /* Emulate expansion trigger.  */
+      size_t nr_elements = size * 3 / 4;
+      while (!(size * 3 <= nr_elements * 4))
+	nr_elements++;
+
+      if (nr_elements > final_nr_elements)
+	{
+	  nr_elements = final_nr_elements;
+	  break;
+	}
+
+      /* Emulate expansion.  */
+      size = size * 2;
+      size = higher_prime_number (size);
+    }
+
+  return size;
+}
+
+/* Print hash table statistics for hash table HTAB with message string MSG.  */
+static void
+htab_report (htab_t htab, const char *msg)
+{
+  double collisions = htab_collisions (htab);
+  unsigned int searches = htab->searches;
+  size_t elements = htab->n_elements;
+  size_t deleted = htab->n_deleted;
+  size_t adjusted_elements = elements - deleted;
+  size_t size = htab->size;
+  double occupancy = (double)elements / (double)size;
+  double adjusted_occupancy = (double)adjusted_elements / (double)size;
+  /* Indent unconditional fprintfs similar to conditional fprintfs to
+     left-align literal strings.  */
+  if (1)
+    fprintf (stderr, "htab: %s\n", msg);
+  if (1)
+    fprintf (stderr, "      size: %zu\n", size);
+  if (elements > 0 && deleted == 0)
+    fprintf (stderr, "      elements: %zu, occupancy: %f\n", elements,
+	     occupancy);
+  if (deleted > 0)
+    fprintf (stderr, "      elements (incl. deleted): %zu, occupancy: %f\n",
+	     elements, occupancy);
+  if (deleted > 0)
+    fprintf (stderr, "      elements (excl. deleted): %zu, occupancy: %f\n",
+	     adjusted_elements, adjusted_occupancy);
+  if (elements > 0)
+    fprintf (stderr, "      searches: %u, collisions: %f\n", searches,
+	     collisions);
+}
+
+/* Hash function for off_htab hash table.  */
+static hashval_t
+off_hash (const void *p)
+{
+  dw_die_ref die = (dw_die_ref) p;
+
+  return die->die_offset / 6;
+}
+
+/* Equality function for off_htab hash table.  */
+static int
+off_eq (const void *p, const void *q)
+{
+  return ((dw_die_ref) p)->die_offset == ((dw_die_ref) q)->die_offset;
+}
+
+/* Hash table to map die_offset values to struct dw_die pointers.  */
+static htab_t off_htab;
+
+/* After read_multifile off_htab is copied over to this variable.
+   Offsets in the alternate .debug_info are found using this hash table.  */
+static htab_t alt_off_htab;
+
+/* Offset hash table for .debug_types section.  */
+static htab_t types_off_htab;
+
+/* Function to add DIE into the hash table (and create the hash table
+   when not already created).  */
+static void
+off_htab_add_die (dw_cu_ref cu, dw_die_ref die, unsigned int *die_count)
+{
+  void **slot;
+
+  if (unlikely (cu->cu_kind == CU_TYPES))
+    {
+      if (types_off_htab == NULL)
+	{
+	  types_off_htab = htab_try_create (100000, off_hash, off_eq, NULL);
+	  if (types_off_htab == NULL)
+	    dwz_oom ();
+	}
+
+      slot = htab_find_slot (types_off_htab, die, INSERT);
+      if (slot == NULL)
+	dwz_oom ();
+      assert (*slot == NULL);
+      *slot = die;
+      return;
+    }
+
+  if (off_htab == NULL)
+    {
+      unsigned int estimated_nr_dies = estimate_nr_dies ();
+      size_t default_initial_size = 100000;
+      size_t initial_size;
+      if (low_mem
+	  || op_multifile
+	  || (multifile_mode == 0
+	      && die_count_method == estimate
+	      && (estimated_nr_dies >= low_mem_die_limit
+		  || estimated_nr_dies >= max_die_limit)))
+	initial_size = default_initial_size;
+      else
+	{
+	  size_t nr_dies;
+	  if (die_count && *die_count != 0)
+	    {
+	      nr_dies = *die_count;
+	      if (tracing)
+		fprintf (stderr, "Using die count %zu for off_htab"
+			 " allocation\n", nr_dies);
+	    }
+	  else if (die_count_method == none)
+	    nr_dies = 0;
+	  else if (die_count_method == estimate)
+	    {
+	      nr_dies = estimated_nr_dies;
+	      if (tracing)
+		fprintf (stderr, "Using die count estimate %zu for off_htab"
+			 " allocation\n", nr_dies);
+	    }
+	  else
+	    assert (false);
+
+	  if (nr_dies != 0)
+	    {
+	      size_t final_hashtab_size
+		= emulate_htab (default_initial_size, nr_dies);
+	      initial_size = final_hashtab_size;
+	    }
+	  else
+	    initial_size = default_initial_size;
+	}
+      off_htab = htab_try_create (initial_size, off_hash, off_eq, NULL);
+      if (tracing)
+	htab_report (off_htab, "off_htab allocation");
+      if (off_htab == NULL)
+	dwz_oom ();
+      if (rd_multifile)
+	alt_off_htab = off_htab;
+    }
+
+  slot = htab_find_slot_with_hash (off_htab, die, off_hash (die), INSERT);
+  if (slot == NULL)
+    dwz_oom ();
+  assert (*slot == NULL);
+  *slot = die;
+}
+
+/* For DIE_OFFSET return dw_die_ref whose die_offset field is equal
+   to that value.  Return NULL if no DIE is at that position (buggy
+   DWARF input?).  */
+static dw_die_ref
+off_htab_lookup (dw_cu_ref cu, unsigned int die_offset)
+{
+  struct dw_die die;
+  die.die_offset = die_offset;
+  if (cu == NULL)
+    return (dw_die_ref) htab_find_with_hash (off_htab, &die, off_hash (&die));
+  if (unlikely (cu->cu_kind == CU_ALT))
+    return (dw_die_ref) htab_find_with_hash (alt_off_htab, &die,
+					     off_hash (&die));
+  if (unlikely (cu->cu_kind == CU_TYPES))
+    return (dw_die_ref) htab_find_with_hash (types_off_htab, &die,
+					     off_hash (&die));
+  return (dw_die_ref) htab_find_with_hash (off_htab, &die, off_hash (&die));
+}
+
+/* For a die attribute ATTR starting at PTR, with the die in CU, return the
+   pointer after the attribute.  */
+static inline unsigned char * FORCE_INLINE
+skip_attr (unsigned int cu_version, struct abbrev_attr *attr,
+	   unsigned char *ptr)
+{
+  uint32_t form = attr->form;
+
+  while (form == DW_FORM_indirect)
+    form = read_uleb128 (ptr);
+  return skip_attr_no_dw_form_indirect (cu_version, form, ptr);
+}
+
+/* Return a pointer at which DIE's attribute AT is encoded, and fill in
+   its form into *FORMP.  Return NULL if the attribute is not present.  */
+static unsigned char *
+get_AT (dw_die_ref die, enum dwarf_attribute at, enum dwarf_form *formp)
+{
+  struct abbrev_tag *t = die->die_abbrev;
+  unsigned int i;
+  unsigned char *ptr;
+  dw_cu_ref cu = die_cu (die);
+  if (unlikely (fi_multifile) && cu->cu_kind == CU_ALT)
+    ptr = alt_data[DEBUG_INFO];
+  else if (cu->cu_kind == CU_TYPES)
+    ptr = debug_sections[DEBUG_TYPES].data;
+  else
+    ptr = debug_sections[DEBUG_INFO].data;
+  ptr += die->die_offset;
+  skip_leb128 (ptr);
+  for (i = 0; i < t->nattr; ++i)
+    {
+      uint32_t form = t->attr[i].form;
+
+      while (form == DW_FORM_indirect)
+	form = read_uleb128 (ptr);
+      if (t->attr[i].attr == at)
+	{
+	  *formp = form;
+	  if (form == DW_FORM_implicit_const)
+	    return (unsigned char *) &t->values[i];
+	  return ptr;
+	}
+
+      ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+    }
+  return NULL;
+}
+
+/* Return an integer attribute AT of DIE.  Set *PRESENT to true
+   if found.  */
+static uint64_t
+get_AT_int (dw_die_ref die, enum dwarf_attribute at, bool *present,
+	    enum dwarf_form *formp)
+{
+  unsigned char *ptr;
+  ptr = get_AT (die, at, formp);
+  *present = false;
+  if (ptr == NULL)
+    return 0;
+  *present = true;
+  switch (*formp)
+    {
+    case DW_FORM_ref_addr:
+      return read_size (ptr, die_cu (die)->cu_version == 2 ? ptr_size : 4);
+    case DW_FORM_addr:
+      return read_size (ptr, ptr_size);
+    case DW_FORM_flag_present:
+      return 1;
+    case DW_FORM_ref1:
+    case DW_FORM_flag:
+    case DW_FORM_data1:
+      return read_8 (ptr);
+    case DW_FORM_ref2:
+    case DW_FORM_data2:
+      return read_16 (ptr);
+    case DW_FORM_ref4:
+    case DW_FORM_data4:
+    case DW_FORM_sec_offset:
+      return read_32 (ptr);
+    case DW_FORM_ref8:
+    case DW_FORM_data8:
+    case DW_FORM_ref_sig8:
+      return read_64 (ptr);
+    case DW_FORM_sdata:
+      return read_sleb128 (ptr);
+    case DW_FORM_ref_udata:
+    case DW_FORM_udata:
+      return read_uleb128 (ptr);
+    case DW_FORM_implicit_const:
+      return *(uint64_t *)ptr; /* See get_AT.  */
+    default:
+      *present = false;
+      return 0;
+    }
+}
+
+/* Return a pointer to string attribute AT in DIE, or NULL
+   if the attribute is not present.  */
+static char *
+get_AT_string (dw_die_ref die, enum dwarf_attribute at)
+{
+  enum dwarf_form form;
+  unsigned char *ptr;
+  ptr = get_AT (die, at, &form);
+  if (ptr == NULL)
+    return NULL;
+  switch (form)
+    {
+    case DW_FORM_string:
+      return (char *) ptr;
+    case DW_FORM_strp:
+      {
+	unsigned int strp = read_32 (ptr);
+	if (unlikely (fi_multifile) && die_cu (die)->cu_kind == CU_ALT)
+	  {
+	    if (strp >= alt_size[DEBUG_STR])
+	      return NULL;
+	    return (char *) alt_data[DEBUG_STR] + strp;
+	  }
+	if (strp >= debug_sections[DEBUG_STR].size)
+	  return NULL;
+	return (char *) debug_sections[DEBUG_STR].data + strp;
+      }
+    case DW_FORM_line_strp:
+      {
+	unsigned int line_strp = read_32 (ptr);
+	if (line_strp >= debug_sections[DEBUG_LINE_STR].size)
+	  return NULL;
+	else
+	  return (char *) debug_sections[DEBUG_LINE_STR].data + line_strp;
+      }
+    default:
+      return NULL;
+    }
+}
+
+/* Parse DWARF expression referenced or stored in DIE, starting at
+   PTR with LEN bytes.  Return non-zero on error.  If NEED_ADJUST
+   is non-NULL, set *NEED_ADJUST to true if it contains DIE references
+   that will need adjusting.  Some opcodes cause DIE or referenced
+   DIEs as unsuitable for moving into partial units, or limit their
+   location.  */
+static int
+read_exprloc (DSO *dso, dw_die_ref die, unsigned char *ptr, size_t len,
+	      bool *need_adjust)
+{
+  unsigned char *end = ptr + len;
+  unsigned char op;
+  GElf_Addr addr;
+  dw_die_ref ref;
+  dw_cu_ref cu;
+
+  while (ptr < end)
+    {
+      op = *ptr++;
+      switch (op)
+	{
+	case DW_OP_addr:
+	  die->die_no_multifile = 1;
+	  ptr += ptr_size;
+	  break;
+	case DW_OP_deref:
+	case DW_OP_dup:
+	case DW_OP_drop:
+	case DW_OP_over:
+	case DW_OP_swap:
+	case DW_OP_rot:
+	case DW_OP_xderef:
+	case DW_OP_abs:
+	case DW_OP_and:
+	case DW_OP_div:
+	case DW_OP_minus:
+	case DW_OP_mod:
+	case DW_OP_mul:
+	case DW_OP_neg:
+	case DW_OP_not:
+	case DW_OP_or:
+	case DW_OP_plus:
+	case DW_OP_shl:
+	case DW_OP_shr:
+	case DW_OP_shra:
+	case DW_OP_xor:
+	case DW_OP_eq:
+	case DW_OP_ge:
+	case DW_OP_gt:
+	case DW_OP_le:
+	case DW_OP_lt:
+	case DW_OP_ne:
+	case DW_OP_lit0 ... DW_OP_lit31:
+	case DW_OP_reg0 ... DW_OP_reg31:
+	case DW_OP_nop:
+	case DW_OP_push_object_address:
+	case DW_OP_form_tls_address:
+	case DW_OP_call_frame_cfa:
+	case DW_OP_stack_value:
+	case DW_OP_GNU_push_tls_address:
+	case DW_OP_GNU_uninit:
+	  break;
+	case DW_OP_const1u:
+	case DW_OP_pick:
+	case DW_OP_deref_size:
+	case DW_OP_xderef_size:
+	case DW_OP_const1s:
+	  ++ptr;
+	  break;
+	case DW_OP_const2u:
+	case DW_OP_const2s:
+	case DW_OP_skip:
+	case DW_OP_bra:
+	  ptr += 2;
+	  break;
+	case DW_OP_call2:
+	case DW_OP_call4:
+	case DW_OP_GNU_parameter_ref:
+	  if (op == DW_OP_call2)
+	    addr = read_16 (ptr);
+	  else
+	    addr = read_32 (ptr);
+	  cu = die_cu (die);
+	  ref = off_htab_lookup (cu, cu->cu_offset + addr);
+	  if (ref == NULL)
+	    {
+	      error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+		     "referenced by %s from DIE at [%x]",
+		     dso->filename, cu->cu_offset + addr,
+		     get_DW_OP_str (op), die->die_offset);
+	      return 1;
+	    }
+	  if (op == DW_OP_call2)
+	    ref->die_op_call2_referenced = 1;
+	  if (ref->die_ck_state == CK_KNOWN)
+	    {
+	      dw_die_ref d;
+	      ref->die_ck_state = CK_BAD;
+
+	      d = ref;
+	      while (!d->die_root
+		     && d->die_parent->die_ck_state == CK_KNOWN)
+		{
+		  d = d->die_parent;
+		  d->die_ck_state = CK_BAD;
+		}
+	    }
+	  else
+	    ref->die_ck_state = CK_BAD;
+	  if (unlikely (low_mem))
+	    {
+	      ref->die_referenced = 1;
+	      /* As .debug_loc adjustment is done after
+		 write_info finishes, we need to keep the referenced
+		 DIEs around uncollapsed.  */
+	      if (need_adjust)
+		ref->die_intercu_referenced = 1;
+	    }
+	  die->die_ck_state = CK_BAD;
+	  if (need_adjust)
+	    *need_adjust = true;
+	  break;
+	case DW_OP_const4u:
+	case DW_OP_const4s:
+	  ptr += 4;
+	  break;
+	case DW_OP_call_ref:
+	case DW_OP_GNU_implicit_pointer:
+	case DW_OP_implicit_pointer:
+	case DW_OP_GNU_variable_value:
+	  cu = die_cu (die);
+	  addr = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+	  if (cu->cu_version == 2)
+	    ptr += ptr_size;
+	  else
+	    ptr += 4;
+	  ref = off_htab_lookup (NULL, addr);
+	  if (ref == NULL || (unlikely (low_mem) && ref->die_tag == 0))
+	    {
+	      error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+		     "referenced by %s from DIE at [%x]",
+		     dso->filename, addr, get_DW_OP_str (op), die->die_offset);
+	      return 1;
+	    }
+	  ref->die_no_multifile = 1;
+	  if (unlikely (low_mem))
+	    {
+	      ref->die_referenced = 1;
+	      /* As .debug_loc adjustment is done after
+		 write_info finishes, we need to keep the referenced
+		 DIEs around uncollapsed.  */
+	      if (die_cu (ref) != cu || need_adjust)
+		ref->die_intercu_referenced = 1;
+	    }
+	  die->die_ck_state = CK_BAD;
+	  if (need_adjust)
+	    *need_adjust = true;
+	  if (op == DW_OP_GNU_implicit_pointer || op == DW_OP_implicit_pointer)
+	    skip_leb128 (ptr);
+	  break;
+	case DW_OP_const8u:
+	case DW_OP_const8s:
+	  ptr += 8;
+	  break;
+	case DW_OP_constu:
+	case DW_OP_plus_uconst:
+	case DW_OP_regx:
+	case DW_OP_piece:
+	case DW_OP_consts:
+	case DW_OP_breg0 ... DW_OP_breg31:
+	case DW_OP_fbreg:
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_bregx:
+	case DW_OP_bit_piece:
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_implicit_value:
+	  {
+	    uint32_t leni = read_uleb128 (ptr);
+	    ptr += leni;
+	  }
+	  break;
+	case DW_OP_GNU_entry_value:
+	case DW_OP_entry_value:
+	  {
+	    uint32_t leni = read_uleb128 (ptr);
+	    if ((uint64_t) (end - ptr) < leni)
+	      {
+		error (0, 0, "%s: %s with too large length",
+		       get_DW_OP_str (op),  dso->filename);
+		return 1;
+	      }
+	    if (read_exprloc (dso, die, ptr, leni, need_adjust))
+	      return 1;
+	    ptr += leni;
+	  }
+	  break;
+	case DW_OP_GNU_convert:
+	case DW_OP_convert:
+	case DW_OP_GNU_reinterpret:
+	case DW_OP_reinterpret:
+	  addr = read_uleb128 (ptr);
+	  if (addr == 0)
+	    break;
+	  goto typed_dwarf;
+	case DW_OP_GNU_regval_type:
+	case DW_OP_regval_type:
+	  skip_leb128 (ptr);
+	  addr = read_uleb128 (ptr);
+	  goto typed_dwarf;
+	case DW_OP_GNU_const_type:
+	case DW_OP_const_type:
+	  addr = read_uleb128 (ptr);
+	  ptr += *ptr + 1;
+	  goto typed_dwarf;
+	case DW_OP_GNU_deref_type:
+	case DW_OP_deref_type:
+	  ++ptr;
+	  addr = read_uleb128 (ptr);
+	typed_dwarf:
+	  cu = die_cu (die);
+	  ref = off_htab_lookup (cu, cu->cu_offset + addr);
+	  if (ref == NULL)
+	    {
+	      error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+			   "referenced by %s from DIE at [%x]",
+		     dso->filename, cu->cu_offset + addr,
+		     get_DW_OP_str (op), die->die_offset);
+	      return 1;
+	    }
+	  if (unlikely (low_mem))
+	    {
+	      ref->die_referenced = 1;
+	      /* As .debug_loc adjustment is done after
+		 write_info finishes, we need to keep the referenced
+		 DIEs around uncollapsed.  */
+	      if (need_adjust)
+		ref->die_intercu_referenced = 1;
+	    }
+	  ref->die_op_type_referenced = 1;
+	  die->die_ck_state = CK_BAD;
+	  if (need_adjust)
+	    *need_adjust = true;
+	  break;
+	default:
+	  error (0, 0, "%s: Unknown DWARF %s "
+		 "referenced from DIE at [%x]",
+		 dso->filename, get_DW_OP_str (op),
+		 die->die_offset);
+	  return 1;
+	}
+    }
+  if (die->die_ck_state != CK_BAD)
+    die->u.p1.die_hash = iterative_hash (end - len, len, die->u.p1.die_hash);
+  return 0;
+}
+
+/* Add dummy die in CU at OFFSET.  */
+static inline void FORCE_INLINE
+add_dummy_die (dw_cu_ref cu, unsigned int offset)
+{
+  dw_die_ref ref;
+  struct dw_die ref_buf;
+  void **slot;
+
+  memset (&ref_buf, '\0', offsetof (struct dw_die, die_child));
+  ref_buf.die_offset = offset;
+  ref_buf.die_collapsed_child = 1;
+  ref_buf.die_referenced = 1;
+  ref_buf.die_intercu_referenced = 1;
+  if (off_htab == NULL)
+    {
+      ref = pool_alloc (dw_die, offsetof (struct dw_die, die_child));
+      memcpy (ref, &ref_buf, offsetof (struct dw_die, die_child));
+      off_htab_add_die (cu, ref, NULL);
+      return;
+    }
+
+  slot
+    = htab_find_slot_with_hash (off_htab, &ref_buf, off_hash (&ref_buf),
+				INSERT);
+  if (slot == NULL)
+    dwz_oom ();
+  if (*slot != NULL)
+    return;
+
+  ref = pool_alloc (dw_die, offsetof (struct dw_die, die_child));
+  memcpy (ref, &ref_buf, offsetof (struct dw_die, die_child));
+  *slot = (void *) ref;
+}
+
+/* Add dummy DIEs for expr_loc at PTR.  */
+static int
+read_exprloc_low_mem_phase1 (DSO *dso, dw_die_ref die, unsigned char *ptr,
+			     size_t len)
+{
+  unsigned char *end = ptr + len;
+  unsigned char op;
+  GElf_Addr addr;
+  dw_cu_ref cu;
+
+  while (ptr < end)
+    {
+      op = *ptr++;
+      switch (op)
+	{
+	case DW_OP_addr:
+	  ptr += ptr_size;
+	  break;
+	case DW_OP_deref:
+	case DW_OP_dup:
+	case DW_OP_drop:
+	case DW_OP_over:
+	case DW_OP_swap:
+	case DW_OP_rot:
+	case DW_OP_xderef:
+	case DW_OP_abs:
+	case DW_OP_and:
+	case DW_OP_div:
+	case DW_OP_minus:
+	case DW_OP_mod:
+	case DW_OP_mul:
+	case DW_OP_neg:
+	case DW_OP_not:
+	case DW_OP_or:
+	case DW_OP_plus:
+	case DW_OP_shl:
+	case DW_OP_shr:
+	case DW_OP_shra:
+	case DW_OP_xor:
+	case DW_OP_eq:
+	case DW_OP_ge:
+	case DW_OP_gt:
+	case DW_OP_le:
+	case DW_OP_lt:
+	case DW_OP_ne:
+	case DW_OP_lit0 ... DW_OP_lit31:
+	case DW_OP_reg0 ... DW_OP_reg31:
+	case DW_OP_nop:
+	case DW_OP_push_object_address:
+	case DW_OP_form_tls_address:
+	case DW_OP_call_frame_cfa:
+	case DW_OP_stack_value:
+	case DW_OP_GNU_push_tls_address:
+	case DW_OP_GNU_uninit:
+	  break;
+	case DW_OP_const1u:
+	case DW_OP_pick:
+	case DW_OP_deref_size:
+	case DW_OP_xderef_size:
+	case DW_OP_const1s:
+	  ++ptr;
+	  break;
+	case DW_OP_const2u:
+	case DW_OP_const2s:
+	case DW_OP_skip:
+	case DW_OP_bra:
+	  ptr += 2;
+	  break;
+	case DW_OP_call2:
+	case DW_OP_call4:
+	case DW_OP_GNU_parameter_ref:
+	  if (op == DW_OP_call2)
+	    read_16 (ptr);
+	  else
+	    read_32 (ptr);
+	  break;
+	case DW_OP_const4u:
+	case DW_OP_const4s:
+	  ptr += 4;
+	  break;
+	case DW_OP_call_ref:
+	case DW_OP_GNU_implicit_pointer:
+	case DW_OP_implicit_pointer:
+	case DW_OP_GNU_variable_value:
+	  cu = die_cu (die);
+	  addr = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+	  if (cu->cu_version == 2)
+	    ptr += ptr_size;
+	  else
+	    ptr += 4;
+	  /* Adding a dummy DIE ref to mark an intercu reference is only
+	     necessary if die_cu (ref) != cu, but we don't track cu's during
+	     low-mem phase1.  */
+	  add_dummy_die (cu, addr);
+	  if (op == DW_OP_GNU_implicit_pointer || op == DW_OP_implicit_pointer)
+	    skip_leb128 (ptr);
+	  break;
+	case DW_OP_const8u:
+	case DW_OP_const8s:
+	  ptr += 8;
+	  break;
+	case DW_OP_constu:
+	case DW_OP_plus_uconst:
+	case DW_OP_regx:
+	case DW_OP_piece:
+	case DW_OP_consts:
+	case DW_OP_breg0 ... DW_OP_breg31:
+	case DW_OP_fbreg:
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_bregx:
+	case DW_OP_bit_piece:
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_implicit_value:
+	  {
+	    uint32_t leni = read_uleb128 (ptr);
+	    ptr += leni;
+	  }
+	  break;
+	case DW_OP_GNU_entry_value:
+	case DW_OP_entry_value:
+	  {
+	    uint32_t leni = read_uleb128 (ptr);
+	    if ((uint64_t) (end - ptr) < leni)
+	      {
+		error (0, 0, "%s: %s with too large length",
+		       get_DW_OP_str (op), dso->filename);
+		return 1;
+	      }
+	    if (read_exprloc_low_mem_phase1 (dso, die, ptr, leni))
+	      return 1;
+	    ptr += leni;
+	  }
+	  break;
+	case DW_OP_GNU_convert:
+	case DW_OP_convert:
+	case DW_OP_GNU_reinterpret:
+	case DW_OP_reinterpret:
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_GNU_regval_type:
+	case DW_OP_regval_type:
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_GNU_const_type:
+	case DW_OP_const_type:
+	  read_uleb128 (ptr);
+	  ptr += *ptr + 1;
+	  break;
+	case DW_OP_GNU_deref_type:
+	case DW_OP_deref_type:
+	  ++ptr;
+	  skip_leb128 (ptr);
+	  break;
+	default:
+	  error (0, 0, "%s: Unknown DWARF %s "
+		 "referenced from DIE at [%x]",
+		 dso->filename, get_DW_OP_str (op),
+		 die->die_offset);
+	  return 1;
+	}
+    }
+
+  return 0;
+}
+
+/* Add dummy DIEs for loclist at OFFSET.  */
+static int
+read_loclist_low_mem_phase1 (DSO *dso, dw_cu_ref cu, dw_die_ref die,
+			     GElf_Addr offset)
+{
+  unsigned char *ptr, *endsec;
+  GElf_Addr low, high;
+  size_t len = 0;
+  int sec;
+
+  sec = cu->cu_version < 5 ? DEBUG_LOC : DEBUG_LOCLISTS;
+  ptr = debug_sections[sec].data;
+  if (ptr == NULL)
+    {
+      error (0, 0, "%s: loclistptr attribute, yet no %s section",
+	     dso->filename, debug_sections[sec].name);
+      return 1;
+    }
+  if (offset >= debug_sections[sec].size)
+    {
+      error (0, 0,
+	     "%s: loclistptr offset %Ld outside of %s section",
+	     dso->filename, (long long) offset, debug_sections[sec].name);
+      return 1;
+    }
+  endsec = ptr + debug_sections[sec].size;
+  ptr += offset;
+again:
+  while (ptr < endsec)
+    {
+      if (sec == DEBUG_LOC)
+	{
+	  low = read_size (ptr, ptr_size);
+	  high = read_size (ptr + ptr_size, ptr_size);
+	  ptr += 2 * ptr_size;
+	  if (low == 0 && high == 0)
+	    break;
+
+	  if (low == ~ (GElf_Addr) 0 || (ptr_size == 4 && low == 0xffffffff))
+	    continue;
+
+	  len = read_16 (ptr);
+	}
+      else
+	{
+	  uint8_t lle = *ptr++;
+	  switch (lle)
+	    {
+	    case DW_LLE_end_of_list:
+	      goto done;
+
+	    case DW_LLE_base_addressx:
+	      skip_leb128 (ptr);
+	      goto again;
+
+	    case DW_LLE_startx_endx:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_startx_length:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_offset_pair:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_default_location:
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_base_address:
+	      ptr += ptr_size;
+	      goto again;
+
+	    case DW_LLE_start_end:
+	      ptr += 2 * ptr_size;
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_start_length:
+	      ptr += ptr_size;
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_GNU_view_pair:
+	      if (cu->cu_version != 5)
+		error (0, 0,
+		       "%s: DW_LLE_GNU_view_pair used with DWARF version %u",
+		       dso->filename, cu->cu_version);
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      goto again;
+
+	    default:
+	      error (0, 0,
+		     "%s: unhandled location list entry 0x%x in %s section",
+		     dso->filename, lle, debug_sections[sec].name);
+	      return 1;
+	    }
+	}
+
+      if (unlikely (!(ptr + len <= endsec)))
+	{
+	  error (0, 0,
+		 "%s: locexpr length 0x%Lx exceeds %s section",
+		 dso->filename, (long long) len, debug_sections[sec].name);
+	  return 1;
+	}
+
+      if (len > 0)
+	if (read_exprloc_low_mem_phase1 (dso, die, ptr, len))
+	  return 1;
+
+      ptr += len;
+    }
+
+done:
+  return 0;
+}
+
+/* Add dummy dies for loc_exprs and loc_lists referenced from DIE.  */
+static int
+add_locexpr_dummy_dies (DSO *dso, dw_cu_ref cu, dw_die_ref die,
+			unsigned char *ptr, uint32_t form, unsigned int attr,
+			size_t len)
+{
+  if (form == DW_FORM_block1 && cu->cu_version < 4)
+    {
+      /* Old DWARF uses blocks instead of exprlocs.  */
+      switch (attr)
+	{
+	case DW_AT_frame_base:
+	case DW_AT_location:
+	case DW_AT_data_member_location:
+	case DW_AT_vtable_elem_location:
+	case DW_AT_byte_size:
+	case DW_AT_bit_offset:
+	case DW_AT_bit_size:
+	case DW_AT_string_length:
+	case DW_AT_lower_bound:
+	case DW_AT_return_addr:
+	case DW_AT_bit_stride:
+	case DW_AT_upper_bound:
+	case DW_AT_count:
+	case DW_AT_segment:
+	case DW_AT_static_link:
+	case DW_AT_use_location:
+	case DW_AT_allocated:
+	case DW_AT_associated:
+	case DW_AT_data_location:
+	case DW_AT_byte_stride:
+	case DW_AT_rank:
+	case DW_AT_call_value:
+	case DW_AT_call_target:
+	case DW_AT_call_target_clobbered:
+	case DW_AT_call_data_location:
+	case DW_AT_call_data_value:
+	case DW_AT_GNU_call_site_value:
+	case DW_AT_GNU_call_site_data_value:
+	case DW_AT_GNU_call_site_target:
+	case DW_AT_GNU_call_site_target_clobbered:
+	  if (read_exprloc_low_mem_phase1 (dso, die, ptr, len))
+	    return 1;
+	default:
+	  break;
+	}
+
+      return 0;
+    }
+
+  if (form == DW_FORM_exprloc)
+    return read_exprloc_low_mem_phase1 (dso, die, ptr, len);
+
+  switch (attr)
+    {
+    case DW_AT_location:
+    case DW_AT_string_length:
+    case DW_AT_return_addr:
+    case DW_AT_data_member_location:
+    case DW_AT_frame_base:
+    case DW_AT_segment:
+    case DW_AT_static_link:
+    case DW_AT_use_location:
+    case DW_AT_vtable_elem_location:
+      if ((cu->cu_version < 4 && form == DW_FORM_data4)
+	  || form == DW_FORM_sec_offset)
+	{
+	  if (read_loclist_low_mem_phase1 (dso, cu, die, do_read_32 (ptr)))
+	    return 1;
+	  break;
+	}
+      else if (cu->cu_version < 4 && form == DW_FORM_data8)
+	{
+	  if (read_loclist_low_mem_phase1 (dso, cu, die, do_read_64 (ptr)))
+	    return 1;
+	  break;
+	}
+      break;
+    default:
+      break;
+    }
+
+  return 0;
+}
+
+/* Structure recording a portion of .debug_loc section that will need
+   adjusting.  */
+struct debug_loc_adjust
+{
+  /* Starting offset in .debug_loc that needs adjusting.  */
+  unsigned int start_offset;
+  /* End offset.  This is used for hashing, as in theory some DIE
+     might be referencing a middle of a .debug_loc sequence (the address
+     part of it) referenced by a different DIE.  */
+  unsigned int end_offset;
+  /* Owning CU.  We give up if the same .debug_loc part that needs adjusting
+     is owned by more than one CU.  */
+  dw_cu_ref cu;
+};
+ALIGN_STRUCT (debug_loc_adjust)
+
+/* Hash table and obstack for recording .debug_loc and .debug_loclists
+   adjustment ranges.  */
+static htab_t loc_htab;
+static htab_t loclists_htab;
+
+/* Hash function for loc[lists]_htab.  */
+static hashval_t
+loc_hash (const void *p)
+{
+  struct debug_loc_adjust *a = (struct debug_loc_adjust *)p;
+
+  return a->end_offset;
+}
+
+/* Equality function for loc[lists]_htab.  */
+static int
+loc_eq (const void *p, const void *q)
+{
+  struct debug_loc_adjust *t1 = (struct debug_loc_adjust *)p;
+  struct debug_loc_adjust *t2 = (struct debug_loc_adjust *)q;
+
+  return t1->end_offset == t2->end_offset;
+}
+
+/* Parse .debug_loc portion starting at OFFSET, referenced by
+   DIE.  Call read_exprloc on each of the DWARF expressions
+   contained in it.  */
+static int
+read_loclist (DSO *dso, dw_cu_ref cu, dw_die_ref die, GElf_Addr offset)
+{
+  unsigned char *ptr, *endsec;
+  GElf_Addr low, high;
+  size_t len;
+  int sec;
+  bool need_adjust = false;
+
+  die->die_ck_state = CK_BAD;
+  sec = cu->cu_version < 5 ? DEBUG_LOC : DEBUG_LOCLISTS;
+  ptr = debug_sections[sec].data;
+  if (ptr == NULL)
+    {
+      error (0, 0, "%s: loclistptr attribute, yet no %s section",
+	     dso->filename, debug_sections[sec].name);
+      return 1;
+    }
+  if (offset >= debug_sections[sec].size)
+    {
+      error (0, 0,
+	     "%s: loclistptr offset %Ld outside of %s section",
+	     dso->filename, (long long) offset, debug_sections[sec].name);
+      return 1;
+    }
+  endsec = ptr + debug_sections[sec].size;
+  ptr += offset;
+again:
+  while (ptr < endsec)
+    {
+      if (cu->cu_version < 5)
+	{
+	  low = read_size (ptr, ptr_size);
+	  high = read_size (ptr + ptr_size, ptr_size);
+	  ptr += 2 * ptr_size;
+	  if (low == 0 && high == 0)
+	    break;
+
+	  if (low == ~ (GElf_Addr) 0 || (ptr_size == 4 && low == 0xffffffff))
+	    continue;
+
+	  len = read_16 (ptr);
+	}
+      else
+	{
+	  uint8_t lle = *ptr++;
+	  switch (lle)
+	    {
+	    case DW_LLE_end_of_list:
+	      goto done;
+
+	    case DW_LLE_base_addressx:
+	      skip_leb128 (ptr);
+	      goto again;
+
+	    case DW_LLE_startx_endx:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_startx_length:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_offset_pair:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_default_location:
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_base_address:
+	      ptr += ptr_size;
+	      goto again;
+
+	    case DW_LLE_start_end:
+	      ptr += 2 * ptr_size;
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_start_length:
+	      ptr += ptr_size;
+	      skip_leb128 (ptr);
+	      len = read_uleb128 (ptr);
+	      break;
+
+	    case DW_LLE_GNU_view_pair:
+	      if (cu->cu_version != 5)
+		error (0, 0,
+		       "%s: DW_LLE_GNU_view_pair used with DWARF version %u",
+		       dso->filename, cu->cu_version);
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      goto again;
+
+	    default:
+	      error (0, 0,
+		     "%s: unhandled location list entry 0x%x in %s section",
+		     dso->filename, lle, debug_sections[sec].name);
+	      return 1;
+	    }
+	}
+
+      if (unlikely (!(ptr + len <= endsec)))
+	{
+	  error (0, 0,
+		 "%s: locexpr length 0x%Lx exceeds %s section",
+		 dso->filename, (long long) len, debug_sections[sec].name);
+	  return 1;
+	}
+
+      if (read_exprloc (dso, die, ptr, len, &need_adjust))
+	return 1;
+
+      ptr += len;
+    }
+
+done:
+  if (need_adjust)
+    {
+      struct debug_loc_adjust adj, *a;
+      void **slot;
+
+      adj.start_offset = offset;
+      adj.end_offset = ptr - debug_sections[sec].data;
+      adj.cu = cu;
+      if (sec == DEBUG_LOC)
+	{
+	  if (loc_htab == NULL)
+	    {
+	      loc_htab = htab_try_create (50, loc_hash, loc_eq, NULL);
+	      if (loc_htab == NULL)
+		dwz_oom ();
+	    }
+	  slot = htab_find_slot_with_hash (loc_htab, &adj, adj.end_offset,
+					   INSERT);
+	}
+      else
+	{
+	  if (loclists_htab == NULL)
+	    {
+	      loclists_htab = htab_try_create (50, loc_hash, loc_eq, NULL);
+	      if (loclists_htab == NULL)
+		dwz_oom ();
+	    }
+	  slot = htab_find_slot_with_hash (loclists_htab, &adj, adj.end_offset,
+					   INSERT);
+	}
+      if (slot == NULL)
+	dwz_oom ();
+      if (*slot == NULL)
+	{
+	  a = pool_alloc (debug_loc_adjust, sizeof (*a));
+	  *a = adj;
+	  *slot = (void *) a;
+	}
+      else if (((struct debug_loc_adjust *)*slot)->cu != adj.cu)
+	{
+	  error (0, 0, "%s: can't adjust %s section because multiple "
+		 "CUs refer to it", dso->filename, debug_sections[sec].name);
+	  return 1;
+	}
+      else if (((struct debug_loc_adjust *)*slot)->start_offset > offset)
+	((struct debug_loc_adjust *)*slot)->start_offset = offset;
+    }
+
+  return 0;
+}
+
+/* Initialize die_odr_state field for DIE with CU.  */
+static void
+set_die_odr_state (dw_cu_ref cu, dw_die_ref die)
+{
+  unsigned char *ptr;
+  struct abbrev_tag *t;
+  unsigned int i;
+  bool decl_p;
+  bool name_p;
+  bool other_p;
+
+  assert (die->die_odr_state == ODR_UNKNOWN);
+  die->die_odr_state = ODR_NONE;
+
+  if (low_mem)
+    /* Todo: allow low-mem mode.  */
+    return;
+
+  if (multifile_mode == 0)
+    /* We're in regular mode, enable the ODR optimization.  */
+    ;
+  else
+    /* One definition rule does not hold across executables and shared
+       libraries, so disable.  */
+    return;
+
+  if (!die->die_toplevel)
+    /* A nested struct is not uniquely identified by its name.  There may be a
+       different type with the same name nested in a different struct.  */
+    return;
+
+  switch (cu->lang)
+    {
+    case DW_LANG_C_plus_plus:
+    case DW_LANG_C_plus_plus_03:
+    case DW_LANG_C_plus_plus_11:
+    case DW_LANG_C_plus_plus_14:
+      /* c++ defines one-definition-rule.  */
+      if (die->die_tag == DW_TAG_structure_type
+	  || die->die_tag == DW_TAG_class_type
+	  || die->die_tag == DW_TAG_union_type)
+	/* ODR holds for all types, but we limit the optimization to these
+	   tags, which are the ones likely to profit from it.  */
+	;
+      else
+	return;
+      break;
+    default:
+      return;
+    }
+
+  ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+  skip_leb128 (ptr);
+
+  t = die->die_abbrev;
+
+  decl_p = false;
+  name_p = false;
+  other_p = false;
+  for (i = 0; i < t->nattr; ++i)
+    {
+      if (t->attr[i].attr == DW_AT_name)
+	{
+	  name_p = true;
+	  continue;
+	}
+
+      if (t->attr[i].attr == DW_AT_declaration)
+	{
+	  decl_p = true;
+	  continue;
+	}
+
+      other_p = true;
+    }
+
+  if (!name_p)
+    /* Ignore anonymous types.  */
+    return;
+
+  odr_active_p = true;
+
+  if (decl_p && !other_p && die->die_child == NULL)
+    {
+      /* Detected a declaration with no attributes other than DW_AT_name and
+	 DW_AT_declaration, and no children.  */
+      die->die_odr_state = ODR_DECL;
+      return;
+    }
+
+  die->die_odr_state = ODR_DEF;
+}
+
+/* Return the initialized die_odr_state field for DIE with CU.  */
+static unsigned int
+die_odr_state (dw_die_ref die)
+{
+  assert (die->die_odr_state != ODR_UNKNOWN);
+  return die->die_odr_state;
+}
+
+/* This function computes u.p1.die_hash and die_ck_state of DIE.
+   The field u.p1.die_hash is an iterative hash of:
+   - the die_tag,
+   - for all attributes except DW_AT_sibling: the attribute code,
+   - for non-reference class attributes: the value of the attribute (magic
+     for DW_AT_*_file),
+   - for DW_FORM_ref_addr attributes: the value of the attribute,
+   - for reference class attributes that point into the subtree of TOP_DIE
+     (note, other references are intentionally ignored here):
+     ref->u.p1.die_enter - top_die->u.p1.die_enter,
+   - for all children: their hashes.
+   The field die_ck_state is set to CK_BAD if the die is unsuitable for
+   moving into a partial unit (contains code references or other reasons).
+   TOP_DIE is initially NULL when DW_TAG_*_unit or die_named_namespace dies
+   are walked.  */
+static int
+checksum_die (DSO *dso, dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die)
+{
+  unsigned short s;
+  struct abbrev_tag *t;
+  unsigned int i;
+  unsigned char *ptr;
+  dw_die_ref child;
+  bool only_hash_name_p;
+  hashval_t die_hash2;
+
+  switch (die->die_ck_state)
+    {
+    case CK_UNKNOWN:
+      break;
+    case CK_KNOWN:
+    case CK_BAD:
+      return 0;
+    case CK_BEING_COMPUTED:
+      die->die_ck_state = CK_BAD;
+      return 0;
+    }
+  die->die_ck_state = CK_BEING_COMPUTED;
+  die->u.p1.die_hash = 0;
+  if (die->die_tag == DW_TAG_compile_unit
+      || die->die_tag == DW_TAG_partial_unit
+      || die->die_tag == DW_TAG_namespace
+      || die->die_tag == DW_TAG_module
+      || die->die_tag == DW_TAG_imported_unit)
+    die->die_ck_state = CK_BAD;
+  t = die->die_abbrev;
+  ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+  skip_leb128 (ptr);
+  s = die->die_tag;
+  die->u.p1.die_hash = iterative_hash_object (s, die->u.p1.die_hash);
+  if (dump_checksum_p)
+    fprintf (stderr, "DIE %x, hash: %x, tag\n", die->die_offset,
+	     die->u.p1.die_hash);
+  if (uni_lang_p && die == top_die)
+    {
+      die->u.p1.die_hash
+	= iterative_hash_object (cu->lang, die->u.p1.die_hash);
+      if (dump_checksum_p)
+	fprintf (stderr, "DIE %x, hash: %x, lang\n", die->die_offset,
+		 die->u.p1.die_hash);
+    }
+
+  if (odr && die->die_odr_state == ODR_UNKNOWN)
+    set_die_odr_state (die_cu (die), die);
+  only_hash_name_p = odr && die_odr_state (die) != ODR_NONE;
+  die_hash2 = 0;
+  if (only_hash_name_p)
+    die_hash2 = die->u.p1.die_hash;
+  for (i = 0; i < t->nattr; ++i)
+    {
+      uint32_t form = t->attr[i].form;
+      size_t len = 0;
+      unsigned char *old_ptr;
+      bool handled = false;
+      int64_t svalue;
+      uint64_t value;
+
+      while (form == DW_FORM_indirect)
+	form = read_uleb128 (ptr);
+      old_ptr = ptr;
+
+      switch (t->attr[i].attr)
+	{
+	/* Ignore DW_AT_sibling attribute.  */
+	case DW_AT_sibling:
+	  handled = true;
+	  break;
+	/* These attributes reference code, prevent moving
+	   DIEs with them.  */
+	case DW_AT_low_pc:
+	case DW_AT_high_pc:
+	case DW_AT_entry_pc:
+	case DW_AT_ranges:
+	case DW_AT_call_return_pc:
+	case DW_AT_call_pc:
+	  die->die_ck_state = CK_BAD;
+	  break;
+	case DW_AT_start_scope:
+	  if (form == DW_FORM_sec_offset)
+	    die->die_ck_state = CK_BAD;
+	  break;
+	/* These attributes reference other sections, they
+	   can't be moved to other files easily.  */
+	case DW_AT_stmt_list:
+	case DW_AT_macro_info:
+	case DW_AT_macros:
+	case DW_AT_GNU_macros:
+	  if (!die->die_root)
+	    die->die_no_multifile = 1;
+	  break;
+	/* loclistptr attributes.  */
+	case DW_AT_location:
+	case DW_AT_string_length:
+	case DW_AT_return_addr:
+	case DW_AT_data_member_location:
+	case DW_AT_frame_base:
+	case DW_AT_segment:
+	case DW_AT_static_link:
+	case DW_AT_use_location:
+	case DW_AT_vtable_elem_location:
+	  if ((cu->cu_version < 4 && form == DW_FORM_data4)
+	      || form == DW_FORM_sec_offset)
+	    {
+	      if (read_loclist (dso, cu, die, read_32 (ptr)))
+		return 1;
+	      ptr = old_ptr;
+	      break;
+	    }
+	  else if (cu->cu_version < 4 && form == DW_FORM_data8)
+	    {
+	      if (read_loclist (dso, cu, die, read_64 (ptr)))
+		return 1;
+	      ptr = old_ptr;
+	      break;
+	    }
+	  break;
+	case DW_AT_decl_file:
+	case DW_AT_call_file:
+	  switch (form)
+	    {
+	    case DW_FORM_data1: value = read_8 (ptr); handled = true; break;
+	    case DW_FORM_data2: value = read_16 (ptr); handled = true; break;
+	    case DW_FORM_data4: value = read_32 (ptr); handled = true; break;
+	    case DW_FORM_data8: value = read_64 (ptr); handled = true; break;
+	    case DW_FORM_udata:
+	      value = read_uleb128 (ptr); handled = true; break;
+	    case DW_FORM_sdata:
+	      {
+		svalue = read_sleb128 (ptr);
+		if (svalue >= 0)
+		  {
+		    value = svalue;
+		    handled = true;
+		    break;
+		  }
+		else
+		  {
+		  negative:
+		    error (0, 0, "%s: negative value %" PRId64 " for %s",
+			   dso->filename, svalue,
+			   get_DW_AT_str (t->attr[i].attr));
+		    return 1;
+		  }
+	      }
+	    case DW_FORM_implicit_const:
+	      {
+		svalue = t->values[i];
+		if (svalue >= 0)
+		  {
+		    value = svalue;
+		    handled = true;
+		    break;
+		  }
+		else
+		  goto negative;
+	      }
+	    default:
+	      error (0, 0, "%s: Unhandled %s for %s",
+		     dso->filename, get_DW_FORM_str (form),
+		     get_DW_AT_str (t->attr[i].attr));
+	      return 1;
+	    }
+	  if (handled)
+	    {
+	      unsigned char *new_ptr = ptr;
+	      ptr = old_ptr;
+	      if (value > cu->cu_nfiles)
+		{
+		  error (0, 0, "%s: Invalid %s file number %d",
+			 dso->filename, get_DW_AT_str (t->attr[i].attr),
+			 (int) value);
+		  return 1;
+		}
+	      if (value == 0)
+		handled = false;
+	      else if (!ignore_locus && die->die_ck_state != CK_BAD)
+		{
+		  struct dw_file *cu_file = &cu->cu_files[value - 1];
+		  size_t file_len = strlen (cu_file->file);
+		  s = t->attr[i].attr;
+		  hash_init_state ();
+		  hash_update_state_object (die->u.p1.die_hash);
+		  hash_update_state_object (s);
+		  hash_update_state_object (cu_file->time);
+		  hash_update_state_object (cu_file->size);
+		  hash_update_state (cu_file->file, file_len + 1);
+		  if (cu_file->dir)
+		    {
+		      hash_update_state (cu_file->dir,
+						strlen (cu_file->dir) + 1);
+		    }
+		  /* Ignore DW_AT_comp_dir for DW_AT_*_file <built-in>
+		     etc. if immediately followed by DW_AT_*_line 0.  */
+		  else if (cu_file->file_angle_brackets_encapsulated_no_slash
+			   && i + 1 < t->nattr
+			   && t->attr[i + 1].attr
+			      == (t->attr[i].attr == DW_AT_decl_file
+				  ? DW_AT_decl_line : DW_AT_call_line)
+			   && t->attr[i + 1].form == DW_FORM_data1
+			   && *new_ptr == 0)
+		    {
+		      die->u.p1.die_hash = hash_digest ();
+		      break;
+		    }
+
+		  die->u.p1.die_hash = hash_digest ();
+
+		  if (cu->cu_comp_dir
+		      && (cu_file->dir ? cu_file->dir[0]
+				       : cu_file->file[0]) != '/')
+		    die->u.p1.die_hash
+		      = iterative_hash (cu->cu_comp_dir,
+					strlen (cu->cu_comp_dir) + 1,
+					die->u.p1.die_hash);
+		}
+	    }
+	  break;
+	case DW_AT_decl_line:
+	case DW_AT_decl_column:
+	case DW_AT_call_line:
+	case DW_AT_call_column:
+	  if (ignore_locus)
+	    {
+	      handled = true;
+	      break;
+	    }
+	  switch (form)
+	    {
+	    case DW_FORM_data1: value = read_8 (ptr); handled = true; break;
+	    case DW_FORM_data2: value = read_16 (ptr); handled = true; break;
+	    case DW_FORM_data4: value = read_32 (ptr); handled = true; break;
+	    case DW_FORM_data8: value = read_64 (ptr); handled = true; break;
+	    case DW_FORM_udata:
+	      value = read_uleb128 (ptr); handled = true; break;
+	    case DW_FORM_sdata:
+	      {
+		svalue = read_sleb128 (ptr);
+		if (svalue >= 0)
+		  {
+		    value = svalue;
+		    handled = true;
+		    break;
+		  }
+		else
+		  goto negative;
+	      }
+	    case DW_FORM_implicit_const:
+	      svalue = t->values[i];
+	      if (svalue >= 0)
+		{
+		  value = svalue;
+		  handled = true;
+		  break;
+		}
+	      else
+		goto negative;
+	    default:
+	      error (0, 0, "%s: Unhandled %s for %s",
+		     dso->filename, get_DW_FORM_str (form),
+		     get_DW_AT_str (t->attr[i].attr));
+	      return 1;
+	    }
+	  if (handled)
+	    {
+	      ptr = old_ptr;
+	      s = t->attr[i].attr;
+	      die->u.p1.die_hash
+		= iterative_hash_object (s, die->u.p1.die_hash);
+	      die->u.p1.die_hash
+		= iterative_hash_object (value, die->u.p1.die_hash);
+	    }
+	  break;
+	default:
+	  break;
+	}
+
+      switch (form)
+	{
+	case DW_FORM_ref_addr:
+	  if (unlikely (op_multifile || rd_multifile || fi_multifile))
+	    {
+	      dw_die_ref ref;
+
+	      value = read_size (ptr, cu->cu_version == 2
+				      ? ptr_size : 4);
+	      ptr += cu->cu_version == 2 ? ptr_size : 4;
+	      if (die->die_ck_state != CK_BAD)
+		{
+		  s = t->attr[i].attr;
+		  die->u.p1.die_hash
+		    = iterative_hash_object (s, die->u.p1.die_hash);
+		}
+	      ref = off_htab_lookup (cu, value);
+	      if (ref == NULL)
+		{
+		  error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+			       "referenced by %s from DIE at [%x]",
+			 dso->filename, value,
+			 get_DW_AT_str (t->attr[i].attr), die->die_offset);
+		  return 1;
+		}
+	      if (unlikely (op_multifile) && ref->die_collapsed_child)
+		ref = ref->die_parent;
+	      if (cu == die_cu (ref))
+		{
+		  /* The reference was encoded using a section-relative
+		     encoding, while if it could have been encoded using
+		     CU-relative encoding.  Typically, the latter is used,
+		     because:
+		     - it's potentially smaller, and
+		     - it doesn't require a link-time relocation.  */
+
+		  /* Assert that the multifile only contains section-relative
+		     encoding when necessary.  */
+		  assert (!op_multifile && !rd_multifile);
+
+		  if (fi_multifile)
+		    {
+		      /* It's possible that the input DWARF contains this
+			 sub-optimal reference.  We currently don't optimize
+			 this during single-file optimization, so it will still
+			 be there during finalize_multifile.  Bail out to handle
+			 this conservatively.  */
+		      die->die_ck_state = CK_BAD;
+		      return 0;
+		    }
+		}
+	      /* Assert that during op_multifile, die belongs to the same object
+		 as ref.  */
+	      assert (!op_multifile || cu->cu_chunk == die_cu (ref)->cu_chunk);
+	      handled = true;
+	      break;
+	    }
+	  die->die_no_multifile = 1;
+	  ptr += cu->cu_version == 2 ? ptr_size : 4;
+	  break;
+	case DW_FORM_addr:
+	  die->die_no_multifile = 1;
+	  ptr += ptr_size;
+	  break;
+	case DW_FORM_flag_present:
+	  break;
+	case DW_FORM_implicit_const:
+	  if (!handled && die->die_ck_state != CK_BAD)
+	    {
+	      handled = true;
+	      s = t->attr[i].attr;
+	      die->u.p1.die_hash
+		= iterative_hash_object (s, die->u.p1.die_hash);
+	      die->u.p1.die_hash
+		= iterative_hash_object (t->values[i], die->u.p1.die_hash);
+	    }
+	  break;
+	case DW_FORM_flag:
+	case DW_FORM_data1:
+	  ++ptr;
+	  break;
+	case DW_FORM_data2:
+	  ptr += 2;
+	  break;
+	case DW_FORM_data4:
+	case DW_FORM_sec_offset:
+	  ptr += 4;
+	  break;
+	case DW_FORM_data8:
+	  ptr += 8;
+	  break;
+	case DW_FORM_data16:
+	  ptr += 16;
+	  break;
+	case DW_FORM_ref_sig8:
+	  die->die_no_multifile = 1;
+	  ptr += 8;
+	  break;
+	case DW_FORM_sdata:
+	case DW_FORM_udata:
+	  skip_leb128 (ptr);
+	  break;
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	  switch (form)
+	    {
+	    case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+	    case DW_FORM_ref1: value = read_8 (ptr); break;
+	    case DW_FORM_ref2: value = read_16 (ptr); break;
+	    case DW_FORM_ref4: value = read_32 (ptr); break;
+	    case DW_FORM_ref8: value = read_64 (ptr); break;
+	    default: abort ();
+	    }
+	  if (!handled)
+	    {
+	      dw_die_ref ref
+		= off_htab_lookup (cu, cu->cu_offset + value);
+	      if (ref == NULL)
+		{
+		  error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+			 "referenced by %s from DIE at [%x]",
+			 dso->filename, cu->cu_offset + value,
+			 get_DW_AT_str (t->attr[i].attr), die->die_offset);
+		  return 1;
+		}
+	      if (die->die_ck_state != CK_BAD)
+		{
+		  s = t->attr[i].attr;
+		  die->u.p1.die_hash
+		    = iterative_hash_object (s, die->u.p1.die_hash);
+		}
+	      if (top_die
+		  && !ref->die_collapsed_child
+		  && ref->u.p1.die_enter >= top_die->u.p1.die_enter
+		  && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+		{
+		  if (die->die_ck_state != CK_BAD)
+		    {
+		      unsigned int val
+			= ref->u.p1.die_enter - top_die->u.p1.die_enter;
+		      die->u.p1.die_hash
+			= iterative_hash_object (val, die->u.p1.die_hash);
+		    }
+		}
+	      handled = true;
+	    }
+	  break;
+	case DW_FORM_strp:
+	  if (unlikely (op_multifile || rd_multifile || fi_multifile)
+	      && die->die_ck_state != CK_BAD)
+	    {
+	      value = read_32 (ptr);
+	      if (value >= debug_sections[DEBUG_STR].size)
+		die->die_ck_state = CK_BAD;
+	      else
+		{
+		  unsigned char *p = debug_sections[DEBUG_STR].data + value;
+		  unsigned int l = strlen ((char *) p) + 1;
+		  s = t->attr[i].attr;
+		  die->u.p1.die_hash
+		    = iterative_hash_object (s, die->u.p1.die_hash);
+		  die->u.p1.die_hash
+		    = iterative_hash (p, l, die->u.p1.die_hash);
+		  handled = true;
+		}
+	    }
+	  else
+	    {
+	      ptr += 4;
+	      if (only_hash_name_p && t->attr[i].attr == DW_AT_name)
+		{
+		  s = t->attr[i].attr;
+		  die_hash2 = iterative_hash_object (s, die_hash2);
+		  die_hash2
+		    = iterative_hash (old_ptr, ptr - old_ptr, die_hash2);
+		}
+	    }
+	  break;
+	case DW_FORM_line_strp:
+	  /* There is no .debug_line_str in the alt file, so we cannot
+	     move this DIE unless we change the string reference.
+	     This is not that bad because DW_FORM_line_strp is often
+	     only used in the CU DIE for file name and comp_dir and we
+	     don't move the CU DIE anyway.  */
+	  die->die_ck_state = CK_BAD;
+	  break;
+	case DW_FORM_string:
+	  ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+	  if (only_hash_name_p && t->attr[i].attr == DW_AT_name)
+	    {
+	      s = t->attr[i].attr;
+	      die_hash2 = iterative_hash_object (s, die_hash2);
+	      die_hash2
+		= iterative_hash (old_ptr, ptr - old_ptr, die_hash2);
+	    }
+	  break;
+	case DW_FORM_indirect:
+	  abort ();
+	case DW_FORM_block1:
+	  len = *ptr++;
+	  break;
+	case DW_FORM_block2:
+	  len = read_16 (ptr);
+	  form = DW_FORM_block1;
+	  break;
+	case DW_FORM_block4:
+	  len = read_32 (ptr);
+	  form = DW_FORM_block1;
+	  break;
+	case DW_FORM_block:
+	  len = read_uleb128 (ptr);
+	  form = DW_FORM_block1;
+	  break;
+	case DW_FORM_exprloc:
+	  len = read_uleb128 (ptr);
+	  break;
+	default:
+	  abort ();
+	}
+
+      if (form == DW_FORM_block1 && cu->cu_version < 4)
+	{
+	  /* Old DWARF uses blocks instead of exprlocs.  */
+	  switch (t->attr[i].attr)
+	    {
+	    case DW_AT_frame_base:
+	    case DW_AT_location:
+	    case DW_AT_data_member_location:
+	    case DW_AT_vtable_elem_location:
+	    case DW_AT_byte_size:
+	    case DW_AT_bit_offset:
+	    case DW_AT_bit_size:
+	    case DW_AT_string_length:
+	    case DW_AT_lower_bound:
+	    case DW_AT_return_addr:
+	    case DW_AT_bit_stride:
+	    case DW_AT_upper_bound:
+	    case DW_AT_count:
+	    case DW_AT_segment:
+	    case DW_AT_static_link:
+	    case DW_AT_use_location:
+	    case DW_AT_allocated:
+	    case DW_AT_associated:
+	    case DW_AT_data_location:
+	    case DW_AT_byte_stride:
+	    case DW_AT_rank:
+	    case DW_AT_call_value:
+	    case DW_AT_call_target:
+	    case DW_AT_call_target_clobbered:
+	    case DW_AT_call_data_location:
+	    case DW_AT_call_data_value:
+	    case DW_AT_GNU_call_site_value:
+	    case DW_AT_GNU_call_site_data_value:
+	    case DW_AT_GNU_call_site_target:
+	    case DW_AT_GNU_call_site_target_clobbered:
+	      if (die->die_ck_state != CK_BAD)
+		{
+		  s = t->attr[i].attr;
+		  die->u.p1.die_hash
+		    = iterative_hash_object (s, die->u.p1.die_hash);
+		}
+	      if (read_exprloc (dso, die, ptr, len, NULL))
+		return 1;
+	      handled = true;
+	    default:
+	      break;
+	    }
+	}
+      else if (form == DW_FORM_exprloc)
+	{
+	  if (die->die_ck_state != CK_BAD)
+	    {
+	      s = t->attr[i].attr;
+	      die->u.p1.die_hash
+		= iterative_hash_object (s, die->u.p1.die_hash);
+	    }
+	  if (read_exprloc (dso, die, ptr, len, NULL))
+	    return 1;
+	  handled = true;
+	}
+      ptr += len; /* Skip expr/blocks.  */
+      if (!handled && die->die_ck_state != CK_BAD)
+	{
+	  s = t->attr[i].attr;
+	  die->u.p1.die_hash = iterative_hash_object (s, die->u.p1.die_hash);
+	  die->u.p1.die_hash
+	    = iterative_hash (old_ptr, ptr - old_ptr, die->u.p1.die_hash);
+	}
+
+      if (dump_checksum_p)
+	fprintf (stderr, "DIE %x, hash: %x, attr (%d)\n", die->die_offset,
+		 die->u.p1.die_hash, i);
+    }
+
+  for (child = die->die_child, i = 0; child; child = child->die_sib, ++i)
+    if (checksum_die (dso, cu,
+		      top_die ? top_die
+			      : child->die_named_namespace
+			      ? NULL : child, child))
+      return 1;
+    else if (die->die_ck_state != CK_BAD)
+      {
+	if (child->die_ck_state == CK_KNOWN)
+	  {
+	    die->u.p1.die_hash
+	      = iterative_hash_object (child->u.p1.die_hash,
+				       die->u.p1.die_hash);
+	    if (dump_checksum_p)
+	      fprintf (stderr, "DIE %x, hash: %x, child (%i)\n",
+		       die->die_offset, die->u.p1.die_hash, i);
+	    die->die_no_multifile
+	      |= child->die_no_multifile;
+	  }
+	else
+	  die->die_ck_state = CK_BAD;
+      }
+  if (die->die_ck_state == CK_BEING_COMPUTED)
+    die->die_ck_state = CK_KNOWN;
+
+  if (dump_checksum_p)
+    fprintf (stderr, "DIE %x, hash: %x, final\n", die->die_offset,
+	     die->u.p1.die_hash);
+
+  if (only_hash_name_p)
+    {
+      unsigned int tmp = die->u.p1.die_hash;
+      die->u.p1.die_hash = die_hash2;
+      die->u.p1.die_hash2 = tmp;
+    }
+
+  return 0;
+}
+
+/* Helper function for checksum_ref_die to sort DIE pointers
+   by increasing u.p1.die_hash.  */
+static int
+checksum_ref_die_cmp (const void *p, const void *q)
+{
+  dw_die_ref die1 = *(dw_die_ref *)p;
+  dw_die_ref die2 = *(dw_die_ref *)q;
+  if (die1->u.p1.die_hash < die2->u.p1.die_hash)
+    return -1;
+  if (die1->u.p1.die_hash > die2->u.p1.die_hash)
+    return 1;
+  /* The rest is just to keep the sort stable.  If there is more than
+     one DIE with the same hash, we don't consider any of them as suitable
+     starting point for the walk.  */
+  if (die1->die_offset < die2->die_offset)
+    return -1;
+  if (die1->die_offset > die2->die_offset)
+    return 1;
+  return 0;
+}
+
+/* This function is the second phase of hash computation, which computes
+   u.p1.die_ref_hash after u.p1.die_hash has been computed.
+   u.p1.die_ref_hash is an iterative hash of the references (other than
+   those checksummed already into u.p1.die_hash by checksum_die).
+   u.p1.die_ref_hash is only computed for the toplevel DIEs, i.e. children
+   of DW_TAG_*_unit or die_named_namespace DIEs.  So, in the graph
+   containing DIEs as nodes and parent<->child and referrer<->referree edges
+   we virtually coalesce all children of toplevel DIEs into the
+   corresponding toplevel DIE ultimate parent node.  The function has 4
+   modes of operation:
+
+   The first one is when TOP_DIE, SECOND_IDX and SECOND_HASH are all NULL,
+   this is when we walk through DW_TAG_*_unit and die_named_namespace DIEs
+   to reach their children.
+
+   The second mode of operation is with TOP_DIE != NULL and both SECOND_IDX
+   and SECOND_HASH NULL.  In this mode we optimistically assume there are no
+   cycles in the graph, first hash into TOP_DIE's u.p1.die_ref_hash its
+   u.p1.die_hash, push the TOP_DIE into a vector (in OB obstack), for each
+   reference if the referree isn't already toplevel DIE find its
+   (grand)*parent that is a toplevel DIE, recurse on that and if it computed
+   the referree toplevel DIE's u.p1.die_ref_hash (i.e. no cycle),
+   iteratively hash in the referree toplevel DIE's u.p1.die_ref_hash (and,
+   if referree isn't toplevel, before that also its relative position in the
+   subtree).  When existing, remove the TOP_DIE from the vector and set
+   die_ref_hash_computed to note that it is computed and doesn't have to be
+   computed again.  If there are no cycles, the return value of the function
+   is 0.  If a cycle is found, things are more complicated.  We can't just
+   not walk into DIEs we've already seen and compute u.p1.die_ref_hash for
+   toplevel DIEs on the cycle(s), because in different CUs matching cycles
+   might be starting computation of the hash from different nodes on the
+   cycle (the order of children of DW_TAG_*_unit or DW_TAG_namespace is
+   usually not significant in DWARF).  So, if a cycle is found, the return
+   value is a minimum of the die_ref_seen indexes (positions in the
+   vector); at that point it makes no sense to further compute
+   u.p1.die_ref_hash of the toplevel DIEs on the cycle, but for references
+   to acyclic subgraphs we still continue computing their u.p1.die_ref_hash.
+   For DIEs on the cycle(s) pointers to them aren't immediately removed from
+   the vector and everything is handled only after reaching the TOP_DIE with
+   die_ref_seen equal to the minimum vector index (i.e. the first of
+   the DIEs on the cycle(s) we've seen).  At this point in the vector
+   starting with that index should be a list of DIEs on the cycle, and all
+   references to (toplevel) DIEs not on that list from those DIEs should
+   have die_ref_hash_computed already set.  If the cycle has matches in
+   different CUs, we should have the same set of u.p1.die_hash values in the
+   list in between all those CUs, but the order might be different.  At this
+   point we try to find a DIE from which to start walk using third mode of
+   operation of this function.  We can't base that decision on e.g.
+   die_offset, as it may be not just different between the CUs, but the
+   matching DIEs might be in different relative orders.  So we look if there
+   is just a single DIE with lowest u.p1.die_hash value and use that in that
+   case, (and if not, look if there is just a single DIE with second lowest
+   u.p1.die_hash and so on up to 20th).  If none is found, the more
+   expensive 4th mode of operation is used instead.
+
+   The third mode of operation is when TOP_DIE, SECOND_IDX and SECOND_HASH
+   are all non-NULL.  This mode is used when the initial TOP_DIE is
+   a uniquely chosen DIE on the cycle (same in each CU that has
+   matching cycle).  In this mode into each TOP_DIE's u.p1.die_ref_hash
+   we hash in *SECOND_IDX (counter when in that walk the DIE has been
+   seen first) and relative referree positions in subtree, and hash in
+   referree toplevel u.p1.die_ref_hash into *SECOND_HASH, and finally
+   when the walk finishes, the caller will compute the final
+   u.p1.die_ref_hash for DIEs on the cycle(s) from their intermediate
+   u.p1.die_ref_hash and *SECOND_HASH.
+
+   The last mode of operation is when TOP_DIE and SECOND_HASH
+   are non-NULL, but SECOND_IDX is NULL.  This mode is used when no
+   suitable DIE from which to start walking the cycle has been discovered.
+   In that case we for each DIE on the cycle walk everything that hasn't
+   die_ref_hash_computed yet, for DIEs seen that have die_ref_hash_computed
+   hash in their u.p1.die_ref_hash, otherwise (DIEs on the current cycle(s))
+   hash in their u.p1.die_hash.  */
+static unsigned int
+checksum_ref_die (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die,
+		  unsigned int *second_idx, hashval_t *second_hash)
+{
+  struct abbrev_tag *t;
+  unsigned int i, ret = 0;
+  unsigned char *ptr;
+  dw_die_ref child;
+
+  if (top_die == die)
+    {
+      if (die->die_ref_hash_computed)
+	return 0;
+      if (die->die_ck_state != CK_KNOWN)
+	return 0;
+      if (die->die_ref_seen)
+	return second_hash != NULL ? 0 : die->die_ref_seen;
+      if (second_hash != NULL)
+	{
+	  die->die_ref_seen = 1;
+	  if (second_idx != NULL)
+	    {
+	      die->u.p1.die_ref_hash
+		= iterative_hash_object (*second_idx, die->u.p1.die_hash);
+	      (*second_idx)++;
+	    }
+	}
+      else
+	{
+	  die->die_ref_seen
+	    = obstack_object_size (&ob) / sizeof (void *) + 1;
+	  obstack_ptr_grow (&ob, die);
+	  die->u.p1.die_ref_hash = die->u.p1.die_hash;
+	}
+    }
+  else
+    assert (top_die == NULL || die->die_ck_state == CK_KNOWN);
+  t = die->die_abbrev;
+  for (i = 0; i < t->nattr; ++i)
+    if (t->attr[i].attr != DW_AT_sibling)
+      switch (t->attr[i].form)
+	{
+	case DW_FORM_ref_addr:
+	  if (unlikely (op_multifile || rd_multifile || fi_multifile))
+	    i = -2U;
+	  break;
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	case DW_FORM_indirect:
+	  i = -2U;
+	  break;
+	}
+  if (i == -1U)
+    {
+      ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+      skip_leb128 (ptr);
+      for (i = 0; i < t->nattr; ++i)
+	{
+	  uint32_t form = t->attr[i].form;
+	  size_t len = 0;
+	  uint64_t value;
+	  dw_die_ref ref, reft;
+
+	  while (form == DW_FORM_indirect)
+	    form = read_uleb128 (ptr);
+
+	  switch (form)
+	    {
+	    case DW_FORM_ref_addr:
+	      if (unlikely (op_multifile || rd_multifile || fi_multifile))
+		{
+		  value = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+		  ptr += cu->cu_version == 2 ? ptr_size : 4;
+		  assert (t->attr[i].attr != DW_AT_sibling);
+		  if (top_die == NULL)
+		    break;
+		  ref = off_htab_lookup (cu, value);
+		  goto finish_ref;
+		}
+	      ptr += cu->cu_version == 2 ? ptr_size : 4;
+	      break;
+	    case DW_FORM_addr:
+	      ptr += ptr_size;
+	      break;
+	    case DW_FORM_flag_present:
+	    case DW_FORM_implicit_const:
+	      break;
+	    case DW_FORM_flag:
+	    case DW_FORM_data1:
+	      ++ptr;
+	      break;
+	    case DW_FORM_data2:
+	      ptr += 2;
+	      break;
+	    case DW_FORM_data4:
+	    case DW_FORM_sec_offset:
+	    case DW_FORM_strp:
+	    case DW_FORM_line_strp:
+	      ptr += 4;
+	      break;
+	    case DW_FORM_data8:
+	    case DW_FORM_ref_sig8:
+	      ptr += 8;
+	      break;
+	    case DW_FORM_data16:
+	      ptr += 16;
+	      break;
+	    case DW_FORM_sdata:
+	    case DW_FORM_udata:
+	      skip_leb128 (ptr);
+	      break;
+	    case DW_FORM_ref_udata:
+	    case DW_FORM_ref1:
+	    case DW_FORM_ref2:
+	    case DW_FORM_ref4:
+	    case DW_FORM_ref8:
+	      switch (form)
+		{
+		case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+		case DW_FORM_ref1: value = read_8 (ptr); break;
+		case DW_FORM_ref2: value = read_16 (ptr); break;
+		case DW_FORM_ref4: value = read_32 (ptr); break;
+		case DW_FORM_ref8: value = read_64 (ptr); break;
+		default: abort ();
+		}
+	      if (t->attr[i].attr == DW_AT_sibling || top_die == NULL)
+		break;
+	      ref = off_htab_lookup (cu, cu->cu_offset + value);
+	      if (ref->u.p1.die_enter >= top_die->u.p1.die_enter
+		  && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+		break;
+	    finish_ref:
+	      reft = ref;
+	      while (!reft->die_root
+		     && reft->die_parent->die_tag != DW_TAG_compile_unit
+		     && reft->die_parent->die_tag != DW_TAG_partial_unit
+		     && !reft->die_parent->die_named_namespace)
+		reft = reft->die_parent;
+	      if (reft->die_ck_state != CK_KNOWN || reft->die_root)
+		top_die->die_ck_state = CK_BAD;
+	      else
+		{
+		  unsigned int r = checksum_ref_die (die_cu (reft), reft, reft,
+						     second_idx, second_hash);
+		  if (ret == 0 || (r && r < ret))
+		    ret = r;
+		  if (reft->die_ck_state != CK_KNOWN)
+		    top_die->die_ck_state = CK_BAD;
+		  else
+		    top_die->die_no_multifile |= reft->die_no_multifile;
+		}
+	      if (top_die->die_ck_state == CK_BAD)
+		{
+		  if (top_die != die)
+		    return ret;
+		  i = t->nattr - 1;
+		  break;
+		}
+	      if (ret)
+		break;
+	      if (reft != ref)
+		{
+		  unsigned int val
+		    = ref->u.p1.die_enter - reft->u.p1.die_enter;
+		  if (second_hash != NULL && second_idx == NULL)
+		    *second_hash
+		      = iterative_hash_object (val, *second_hash);
+		  else
+		    top_die->u.p1.die_ref_hash
+		      = iterative_hash_object (val,
+					       top_die->u.p1.die_ref_hash);
+		}
+	      if (second_hash)
+		{
+		  if (second_idx == NULL && !reft->die_ref_hash_computed)
+		    *second_hash
+		      = iterative_hash_object (reft->u.p1.die_hash,
+					       *second_hash);
+		  else
+		    *second_hash
+		      = iterative_hash_object (reft->u.p1.die_ref_hash,
+					       *second_hash);
+		}
+	      else
+		top_die->u.p1.die_ref_hash
+		  = iterative_hash_object (reft->u.p1.die_ref_hash,
+					   top_die->u.p1.die_ref_hash);
+	      break;
+	    case DW_FORM_string:
+	      ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+	      break;
+	    case DW_FORM_indirect:
+	      abort ();
+	    case DW_FORM_block1:
+	      len = *ptr++;
+	      break;
+	    case DW_FORM_block2:
+	      len = read_16 (ptr);
+	      form = DW_FORM_block1;
+	      break;
+	    case DW_FORM_block4:
+	      len = read_32 (ptr);
+	      form = DW_FORM_block1;
+	      break;
+	    case DW_FORM_block:
+	    case DW_FORM_exprloc:
+	      len = read_uleb128 (ptr);
+	      form = DW_FORM_block1;
+	      break;
+	    default:
+	      abort ();
+	    }
+
+	  if (form == DW_FORM_block1)
+	    ptr += len;
+	}
+    }
+
+  if (top_die == NULL || top_die->die_ck_state != CK_BAD)
+    {
+      for (child = die->die_child; child; child = child->die_sib)
+	{
+	  unsigned int r
+	    = checksum_ref_die (cu,
+				top_die ? top_die
+				: child->die_named_namespace
+				? NULL : child, child,
+				second_idx, second_hash);
+	  if (top_die == NULL)
+	    assert (r == 0 && obstack_object_size (&ob) == 0);
+
+	  if (ret == 0 || (r && r < ret))
+	    ret = r;
+	  if (top_die && top_die->die_ck_state == CK_BAD)
+	    break;
+	}
+     }
+
+  if (top_die == die)
+    {
+      if (ret == 0)
+	{
+	  if (second_hash != NULL)
+	    return 0;
+	  die->die_ref_seen = 0;
+	  die->die_ref_hash_computed = 1;
+	  obstack_blank_fast (&ob, -(int) sizeof (void *));
+	  return 0;
+	}
+      assert (ret <= die->die_ref_seen);
+      if (ret == die->die_ref_seen)
+	{
+	  unsigned int first = die->die_ref_seen - 1;
+	  dw_die_ref *arr;
+	  unsigned int count
+	    = obstack_object_size (&ob) / sizeof (void *) - first;
+	  unsigned int idx, minidx;
+	  hashval_t ref_hash = 0;
+	  bool bad = false;
+	  bool no_multifile = false;
+
+	  arr = (dw_die_ref *) obstack_base (&ob) + first;
+	  for (i = 0; i < count; i++)
+	    {
+	      arr[i]->die_ref_seen = 0;
+	      if (arr[i]->die_ck_state == CK_BAD)
+		bad = true;
+	      else if (arr[i]->die_no_multifile)
+		no_multifile = true;
+	    }
+	  if (bad)
+	    {
+	      for (i = 0; i < count; i++)
+		arr[i]->die_ck_state = CK_BAD;
+	      obstack_blank_fast (&ob, -(int) (count * sizeof (void *)));
+	      return 0;
+	    }
+	  /* Find the DIE in the array with the smallest u.p1.die_hash.  */
+	  for (i = 0, minidx = -1U, bad = true; i < count; i++)
+	    {
+	      if (no_multifile)
+		arr[i]->die_no_multifile = 1;
+	      if (minidx == -1U
+		  || arr[i]->u.p1.die_hash < arr[minidx]->u.p1.die_hash)
+		{
+		  minidx = i;
+		  bad = false;
+		}
+	      else if (arr[i]->u.p1.die_hash == arr[minidx]->u.p1.die_hash)
+		bad = true;
+	    }
+	  if (bad)
+	    {
+	      unsigned int iter, limv;
+	      /* If there is more than one smallest u.p1.die_hash,
+		 look for second (up to 6th) smallest u.p1.die_hash
+		 if there is just one of that value.  */
+	      for (iter = 0; iter < 5; iter++)
+		{
+		  limv = arr[minidx]->u.p1.die_hash;
+		  for (i = 0, minidx = -1U, bad = true; i < count; i++)
+		    if (arr[i]->u.p1.die_hash <= limv)
+		      continue;
+		    else if (minidx == -1U
+			     || arr[i]->u.p1.die_hash
+				< arr[minidx]->u.p1.die_hash)
+		      {
+			minidx = i;
+			bad = false;
+		      }
+		    else if (arr[i]->u.p1.die_hash
+			     == arr[minidx]->u.p1.die_hash)
+		      bad = true;
+		  if (minidx == -1U || !bad)
+		    break;
+		}
+	      /* If all of 1st to 6th smallest u.p1.die_hash has more than
+		 one DIE with that u.p1.die_hash, sort the array and find
+		 the smallest u.p1.die_hash that only a single DIE has.  */
+	      if (minidx != -1U && iter == 5)
+		{
+		  unsigned int j;
+		  qsort (arr, count, sizeof (void *), checksum_ref_die_cmp);
+		  for (i = 0, minidx = -1U; i < count; i = j)
+		    {
+		      if (i + 1 == count
+			  || arr[i + 1]->u.p1.die_hash
+			     != arr[i]->u.p1.die_hash)
+			{
+			  minidx = i;
+			  break;
+			}
+		      for (j = i + 1; j < count; j++)
+			if (arr[j]->u.p1.die_hash != arr[i]->u.p1.die_hash)
+			  break;
+		    }
+		}
+	    }
+	  if (checksum_cycle_opt && minidx != -1U)
+	    {
+	      idx = 0;
+	      checksum_ref_die (die_cu (arr[minidx]), arr[minidx],
+				arr[minidx], &idx, &ref_hash);
+	      assert (arr == (dw_die_ref *) obstack_base (&ob) + first);
+	      for (i = 0; i < count; i++)
+		{
+		  arr[i]->u.p1.die_ref_hash
+		    = iterative_hash_object (arr[i]->u.p1.die_ref_hash,
+					     ref_hash);
+		  arr[i]->die_ref_hash_computed = 1;
+		  arr[i]->die_ref_seen = 0;
+		}
+	    }
+	  else
+	    {
+	      /* If we get here, all u.p1.die_hash values in the arr array
+		 are used by more than one DIE.  Do the more expensive
+		 computation as fallback.  */
+	      for (i = 0; i < count; i++)
+		{
+		  unsigned int j;
+		  arr[i]->u.p1.die_ref_hash = arr[i]->u.p1.die_hash;
+		  checksum_ref_die (die_cu (arr[i]), arr[i], arr[i], NULL,
+				    &arr[i]->u.p1.die_ref_hash);
+		  assert (arr == (dw_die_ref *) obstack_base (&ob) + first);
+		  for (j = 0; j < count; j++)
+		    arr[j]->die_ref_seen = 0;
+		}
+	      for (i = 0; i < count; i++)
+		arr[i]->die_ref_hash_computed = 1;
+	    }
+	  obstack_blank_fast (&ob, -(int) (count * sizeof (void *)));
+	  return 0;
+	}
+    }
+  return ret;
+}
+
+/* Hash function for dup_htab.  u.p1.die_ref_hash should have u.p1.die_hash
+   iteratively hashed into it already.  */
+static hashval_t
+die_hash (const void *p)
+{
+  dw_die_ref die = (dw_die_ref) p;
+
+  return die->u.p1.die_ref_hash;
+}
+
+/* Freelist of !die->die_toplevel DIEs, chained through die_sib fields.  */
+static dw_die_ref die_nontoplevel_freelist;
+/* Freelist of die->die_collapsed_child DIEs, chained through die_parent
+   fields.  */
+static dw_die_ref die_collapsed_child_freelist;
+
+/* Return pointer after the attributes of a DIE from a cu with CU_VERSION
+   which uses abbrevs T and starts at PTR.  */
+static unsigned char *
+skip_attrs_1 (unsigned int cu_version, struct abbrev_tag *t, unsigned char *ptr)
+{
+  unsigned int i;
+  for (i = 0; i < t->nattr; ++i)
+    ptr = skip_attr (cu_version, &t->attr[i], ptr);
+
+  return ptr;
+}
+
+/* Return pointer after the attributes of a DIE from CU which uses abbrevs
+   T and starts at PTR.  */
+static unsigned char *
+skip_attrs (dw_cu_ref cu, struct abbrev_tag *t, unsigned char *ptr)
+{
+  return skip_attrs_1 (cu->cu_version, t, ptr);
+}
+
+/* Expand children of TOP_DIE that have been collapsed by
+   collapse_child.  CHECKSUM is true if checksum should be
+   computed - expansion is performed during read_debug_info
+   when duplicates are looked for - or false, if the expansion
+   is performed late (e.g. during compute_abbrevs or write_{info,types}.  */
+static void
+expand_child (dw_die_ref top_die, bool checksum)
+{
+  dw_cu_ref cu = die_cu (top_die);
+  dw_die_ref *diep = &top_die->die_child;
+  dw_die_ref parent = top_die, child;
+  unsigned char *ptr, *base;
+  struct abbrev_tag tag, *t;
+  dw_die_ref die;
+  unsigned int tick = checksum ? top_die->u.p1.die_enter + 1 : 0;
+
+  if (unlikely (cu->cu_kind == CU_TYPES))
+    base = debug_sections[DEBUG_TYPES].data;
+  else
+    base = debug_sections[DEBUG_INFO].data;
+  ptr = base + top_die->die_offset;
+  if (likely (checksum))
+    ptr += top_die->die_size;
+  else
+    {
+      t = top_die->die_abbrev;
+      skip_leb128 (ptr);
+      ptr = skip_attrs (cu, t, ptr);
+    }
+
+  while (1)
+    {
+      unsigned int die_offset = ptr - base;
+      void **slot;
+      struct dw_die diebuf;
+      dw_die_ref collapsed;
+
+      tag.entry = read_uleb128 (ptr);
+      if (tag.entry == 0)
+	{
+	  if (parent == top_die)
+	    break;
+	  diep = &parent->die_sib;
+	  if (checksum)
+	    parent->u.p1.die_exit = tick++;
+	  parent = parent->die_parent;
+	  continue;
+	}
+
+      diebuf.die_offset = die_offset;
+      slot = htab_find_slot_with_hash (cu->cu_kind == CU_TYPES
+				       ? types_off_htab : off_htab,
+				       &diebuf, off_hash (&diebuf), NO_INSERT);
+      if (slot == NULL)
+	die = NULL;
+      else
+	die = (dw_die_ref) *slot;
+      if (die != NULL && !die->die_collapsed_child)
+	{
+	  *diep = die;
+	  die->die_parent = parent;
+	  die->die_ck_state = CK_UNKNOWN;
+	  die->die_ref_seen = 0;
+	  assert (!checksum || die->u.p1.die_enter == tick);
+	  if (die->die_abbrev->children)
+	    {
+	      diep = &die->die_child;
+	      parent = die;
+	    }
+	  else
+	    {
+	      diep = &die->die_sib;
+	      assert (!checksum || die->u.p1.die_exit == tick);
+	    }
+	  tick++;
+	  if (checksum)
+	    ptr = base + die_offset + die->die_size;
+	  else
+	    ptr = skip_attrs (cu, die->die_abbrev, ptr);
+	  continue;
+	}
+
+      collapsed = die;
+      t = htab_find_with_hash (cu->cu_abbrev, &tag, tag.entry);
+      if (die_nontoplevel_freelist)
+	{
+	  die = die_nontoplevel_freelist;
+	  die_nontoplevel_freelist = die->die_sib;
+	}
+      else
+	die = pool_alloc (dw_die, offsetof (struct dw_die, die_dup));
+      memset (die, '\0', offsetof (struct dw_die, die_dup));
+      *diep = die;
+      die->die_tag = t->tag;
+      die->die_abbrev = t;
+      die->die_offset = die_offset;
+      die->die_parent = parent;
+      if (checksum)
+	{
+	  die->u.p1.die_enter = tick;
+	  die->u.p1.die_exit = tick++;
+	}
+      if (t->children)
+	{
+	  diep = &die->die_child;
+	  parent = die;
+	}
+      else
+	diep = &die->die_sib;
+
+      ptr = skip_attrs (cu, t, ptr);
+      die->die_size = (ptr - base) - die_offset;
+      if (collapsed != NULL)
+	{
+	  die->die_referenced = collapsed->die_referenced;
+	  *slot = (void *) die;
+	  memset (collapsed, '\0', offsetof (struct dw_die, die_child));
+	  collapsed->die_parent = die_collapsed_child_freelist;
+	  die_collapsed_child_freelist = collapsed;
+	}
+    }
+  assert (!checksum || top_die->u.p1.die_exit == tick);
+  top_die->die_collapsed_children = 0;
+  if (checksum && likely (cu->cu_kind != CU_TYPES))
+    for (child = top_die->die_child; child; child = child->die_sib)
+      checksum_die (NULL, cu, top_die, child);
+}
+
+/* Call expand_child on all collapsed toplevel children DIEs.  */
+static bool
+expand_children (dw_die_ref die)
+{
+  dw_die_ref child;
+  bool ret = false;
+  for (child = die->die_child; child; child = child->die_sib)
+    if (child->die_named_namespace)
+      ret |= expand_children (child);
+    else if (child->die_collapsed_children)
+      {
+	expand_child (child, false);
+	ret = true;
+      }
+  return ret;
+}
+
+static unsigned odr_phase;
+
+/* Return 1 if DIE1 and DIE2 match.  TOP_DIE1 and TOP_DIE2
+   is the corresponding ultimate parent with die_toplevel
+   set.  u.p1.die_hash and u.p1.die_ref_hash hashes should
+   hopefully ensure that in most cases this function actually
+   just verifies matching.  */
+static int
+die_eq_1 (dw_cu_ref cu1, dw_cu_ref cu2,
+	  dw_die_ref top_die1, dw_die_ref top_die2,
+	  dw_die_ref die1, dw_die_ref die2)
+{
+  struct abbrev_tag *t1, *t2;
+  unsigned int i, j;
+  unsigned char *ptr1, *ptr2;
+  dw_die_ref ref1, ref2;
+  dw_die_ref child1, child2;
+  bool only_compare_name_p;
+
+#define FAIL goto fail
+  if (die1 == die2 || die_safe_dup (die2) == die1)
+    return 1;
+  if (die1->u.p1.die_hash != die2->u.p1.die_hash
+      || die1->u.p1.die_ref_hash != die2->u.p1.die_ref_hash
+      || die1->die_tag != die2->die_tag
+      || (!odr && (die1->u.p1.die_exit - die1->u.p1.die_enter
+		   != die2->u.p1.die_exit - die2->u.p1.die_enter))
+      || die_safe_dup (die2) != NULL
+      || die1->die_ck_state != CK_KNOWN
+      || die2->die_ck_state != CK_KNOWN
+      || die1->die_toplevel != die2->die_toplevel)
+    return 0;
+  assert (!die1->die_root && !die2->die_root);
+
+  if (uni_lang_p && die1 == top_die1 && die2 == top_die2
+      && cu1->lang != cu2->lang)
+    return 0;
+
+  only_compare_name_p
+    = odr && die1->die_odr_state != ODR_NONE && die2->die_odr_state != ODR_NONE;
+
+  if (only_compare_name_p && odr_phase == 1)
+    {
+      const char *name1 = get_AT_string (die1, DW_AT_name);
+      const char *name2 = get_AT_string (die2, DW_AT_name);
+      // TODO: Handle DW_AT_linkage_name?
+      if (name1 == NULL || name2 == NULL)
+	return 0;
+      if (strcmp (name1, name2) != 0)
+	return 0;
+    }
+  else if (die1->u.p1.die_exit - die1->u.p1.die_enter
+	   != die2->u.p1.die_exit - die2->u.p1.die_enter)
+    return 0;
+
+  if (only_compare_name_p && odr_phase == 2
+      && die1->die_odr_state == ODR_DEF && die2->die_odr_state == ODR_DEF)
+    {
+      if (die1->u.p1.die_hash2 != die2->u.p1.die_hash2)
+	return 0;
+    }
+
+  t1 = die1->die_abbrev;
+  t2 = die2->die_abbrev;
+  if (likely (!fi_multifile))
+    {
+      ptr1 = debug_sections[DEBUG_INFO].data + die1->die_offset;
+      ptr2 = debug_sections[DEBUG_INFO].data + die2->die_offset;
+    }
+  else
+    {
+      if (cu1->cu_kind == CU_ALT)
+	ptr1 = alt_data[DEBUG_INFO];
+      else
+	ptr1 = debug_sections[DEBUG_INFO].data;
+      ptr1 += die1->die_offset;
+      if (cu2->cu_kind == CU_ALT)
+	ptr2 = alt_data[DEBUG_INFO];
+      else
+	ptr2 = debug_sections[DEBUG_INFO].data;
+      ptr2 += die2->die_offset;
+    }
+  skip_leb128 (ptr1);
+  skip_leb128 (ptr2);
+  i = 0;
+  j = 0;
+  if (die1->die_toplevel)
+    {
+      for (ref1 = die1->die_parent, ref2 = die2->die_parent; ref1 && ref2; )
+	{
+	  const char *name1, *name2;
+	  if ((ref1->die_tag == DW_TAG_compile_unit
+	       || ref1->die_tag == DW_TAG_partial_unit)
+	      && (ref2->die_tag == DW_TAG_compile_unit
+		  || ref2->die_tag == DW_TAG_partial_unit))
+	    break;
+	  if (ref1->die_tag != ref2->die_tag)
+	    return 0;
+	  if (!ref1->die_named_namespace || !ref2->die_named_namespace)
+	    return 0;
+	  name1 = get_AT_string (ref1, DW_AT_name);
+	  name2 = get_AT_string (ref2, DW_AT_name);
+	  if (strcmp (name1, name2))
+	    return 0;
+	  ref1 = ref1->die_root ? NULL : ref1->die_parent;
+	  ref2 = ref2->die_root ? NULL : ref2->die_parent;
+	}
+      if (ref1 == NULL || ref2 == NULL)
+	return 0;
+      /* For each toplevel die seen, record optimistically
+	 that we expect them to match, to avoid recursing
+	 on it again.  If non-match is determined later,
+	 die_eq wrapper undoes this (which is why the DIE
+	 pointer is added to the vector).  */
+      if (!die2->die_op_type_referenced)
+	die2->die_remove = 1;
+      obstack_ptr_grow (&ob, die2);
+      if (likely (die2->die_nextdup == NULL))
+	{
+	  die2->die_dup = die1;
+	  die2->die_nextdup = die1->die_nextdup;
+	  obstack_ptr_grow (&ob, NULL);
+	}
+      else
+	{
+	  dw_die_ref next;
+	  for (next = die2; next->die_nextdup; next = next->die_nextdup)
+	    next->die_dup = die1;
+	  next->die_dup = die1;
+	  next->die_nextdup = die1->die_nextdup;
+	  obstack_ptr_grow (&ob, next);
+	}
+      die1->die_nextdup = die2;
+    }
+
+  if (only_compare_name_p && odr_phase == 1)
+    return 1;
+
+  while (1)
+    {
+      uint32_t form1, form2;
+      size_t len = 0;
+      unsigned char *old_ptr1;
+      unsigned char *old_ptr2;
+      uint64_t value1, value2;
+
+      while (i < t1->nattr && t1->attr[i].attr == DW_AT_sibling)
+	{
+	  form1 = t1->attr[i].form;
+	  while (form1 == DW_FORM_indirect)
+	    form1 = read_uleb128 (ptr1);
+	  switch (form1)
+	    {
+	    case DW_FORM_ref_udata: skip_leb128 (ptr1); break;
+	    case DW_FORM_ref1: ptr1++; break;
+	    case DW_FORM_ref2: read_16 (ptr1); break;
+	    case DW_FORM_ref4: read_32 (ptr1); break;
+	    case DW_FORM_ref8: read_64 (ptr1); break;
+	    default: FAIL;
+	    }
+	  i++;
+	}
+      while (j < t2->nattr && t2->attr[j].attr == DW_AT_sibling)
+	{
+	  form2 = t2->attr[j].form;
+	  while (form2 == DW_FORM_indirect)
+	    form2 = read_uleb128 (ptr2);
+	  switch (form2)
+	    {
+	    case DW_FORM_ref_udata: skip_leb128 (ptr2); break;
+	    case DW_FORM_ref1: ptr2++; break;
+	    case DW_FORM_ref2: read_16 (ptr2); break;
+	    case DW_FORM_ref4: read_32 (ptr2); break;
+	    case DW_FORM_ref8: read_64 (ptr2); break;
+	    default: FAIL;
+	    }
+	  j++;
+	}
+      if (i == t1->nattr)
+	{
+	  if (j != t2->nattr)
+	    FAIL;
+	  break;
+	}
+      if (j == t2->nattr)
+	FAIL;
+
+      if (t1->attr[i].attr != t2->attr[j].attr)
+	FAIL;
+
+      form1 = t1->attr[i].form;
+      while (form1 == DW_FORM_indirect)
+	form1 = read_uleb128 (ptr1);
+      form2 = t2->attr[j].form;
+      while (form2 == DW_FORM_indirect)
+	form2 = read_uleb128 (ptr2);
+      old_ptr1 = ptr1;
+      old_ptr2 = ptr2;
+
+      switch (t1->attr[i].attr)
+	{
+	case DW_AT_sibling:
+	case DW_AT_low_pc:
+	case DW_AT_high_pc:
+	case DW_AT_entry_pc:
+	case DW_AT_ranges:
+	case DW_AT_call_return_pc:
+	case DW_AT_call_pc:
+	  /* We shouldn't be hitting DIEs with attributes referencing
+	     addresses and we should have removed DW_AT_subling.  */
+	  abort ();
+	case DW_AT_decl_file:
+	case DW_AT_call_file:
+	  switch (form1)
+	    {
+	    case DW_FORM_data1: value1 = read_8 (ptr1); break;
+	    case DW_FORM_data2: value1 = read_16 (ptr1); break;
+	    case DW_FORM_data4: value1 = read_32 (ptr1); break;
+	    case DW_FORM_data8: value1 = read_64 (ptr1); break;
+	    case DW_FORM_udata: value1 = read_uleb128 (ptr1); break;
+	    case DW_FORM_sdata: value1 = read_sleb128 (ptr1); break;
+	    case DW_FORM_implicit_const: value1 = t1->values[i]; break;
+	    default: abort ();
+	    }
+	  switch (form2)
+	    {
+	    case DW_FORM_data1: value2 = read_8 (ptr2); break;
+	    case DW_FORM_data2: value2 = read_16 (ptr2); break;
+	    case DW_FORM_data4: value2 = read_32 (ptr2); break;
+	    case DW_FORM_data8: value2 = read_64 (ptr2); break;
+	    case DW_FORM_udata: value2 = read_uleb128 (ptr2); break;
+	    case DW_FORM_sdata: value2 = read_sleb128 (ptr2); break;
+	    case DW_FORM_implicit_const: value2 = t2->values[j]; break;
+	    default: abort ();
+	    }
+	  if (ignore_locus)
+	    {
+	      i++;
+	      j++;
+	      continue;
+	    }
+	  if ((value1 == 0) ^ (value2 == 0))
+	    FAIL;
+	  if (value1 != 0)
+	    {
+	      struct dw_file *cu_file1
+		= &cu1->cu_files[value1 - 1];
+	      struct dw_file *cu_file2
+		= &cu2->cu_files[value2 - 1];
+
+	      if (cu_file1->time != cu_file2->time
+		  || cu_file1->size != cu_file2->size
+		  || strcmp (cu_file1->file, cu_file2->file))
+		FAIL;
+
+	      if (cu_file1->dir != NULL)
+		{
+		  if (cu_file2->dir == NULL
+		      || strcmp (cu_file1->dir, cu_file2->dir))
+		    FAIL;
+		}
+	      else if (cu_file2->dir != NULL)
+		FAIL;
+	      /* Ignore DW_AT_comp_dir for DW_AT_*_file <built-in>
+		 etc. if immediately followed by DW_AT_*_line 0.  */
+	      else if (cu_file1->file_angle_brackets_encapsulated_no_slash
+		       && i + 1 < t1->nattr
+		       && j + 1 < t2->nattr
+		       && t1->attr[i + 1].attr
+			  == (t1->attr[i].attr == DW_AT_decl_file
+			      ? DW_AT_decl_line : DW_AT_call_line)
+		       && t1->attr[i + 1].form == DW_FORM_data1
+		       && t1->attr[i + 1].attr == t2->attr[j + 1].attr
+		       && t2->attr[j + 1].form == DW_FORM_data1
+		       && *ptr1 == 0
+		       && *ptr2 == 0)
+		{
+		  i++;
+		  j++;
+		  continue;
+		}
+
+	      if ((cu_file1->dir ? cu_file1->dir[0] : cu_file1->file[0])
+		  != '/')
+		{
+		  if (cu1->cu_comp_dir != NULL)
+		    {
+		      if (cu2->cu_comp_dir == NULL
+			  || strcmp (cu1->cu_comp_dir, cu2->cu_comp_dir))
+			FAIL;
+		    }
+		  else if (cu2->cu_comp_dir != NULL)
+		    FAIL;
+		}
+	    }
+	  i++;
+	  j++;
+	  continue;
+	case DW_AT_decl_line:
+	case DW_AT_decl_column:
+	case DW_AT_call_line:
+	case DW_AT_call_column:
+	  if (ignore_locus)
+	    {
+	      old_ptr1 = NULL;
+	      break;
+	    }
+	  switch (form1)
+	    {
+	    case DW_FORM_data1: value1 = read_8 (ptr1); break;
+	    case DW_FORM_data2: value1 = read_16 (ptr1); break;
+	    case DW_FORM_data4: value1 = read_32 (ptr1); break;
+	    case DW_FORM_data8: value1 = read_64 (ptr1); break;
+	    case DW_FORM_udata: value1 = read_uleb128 (ptr1); break;
+	    case DW_FORM_sdata: value1 = read_sleb128 (ptr1); break;
+	    case DW_FORM_implicit_const: value1 = t1->values[i]; break;
+	    default: abort ();
+	    }
+	  switch (form2)
+	    {
+	    case DW_FORM_data1: value2 = read_8 (ptr2); break;
+	    case DW_FORM_data2: value2 = read_16 (ptr2); break;
+	    case DW_FORM_data4: value2 = read_32 (ptr2); break;
+	    case DW_FORM_data8: value2 = read_64 (ptr2); break;
+	    case DW_FORM_udata: value2 = read_uleb128 (ptr2); break;
+	    case DW_FORM_sdata: value2 = read_sleb128 (ptr2); break;
+	    case DW_FORM_implicit_const: value2 = t2->values[j]; break;
+	    default: abort ();
+	    }
+	  if (value1 != value2)
+	    FAIL;
+	  i++;
+	  j++;
+	  continue;
+	default:
+	  break;
+	}
+
+      switch (form1)
+	{
+	case DW_FORM_ref_addr:
+	  if (likely (!op_multifile && !rd_multifile && !fi_multifile))
+	    {
+	      if (form1 != form2)
+		FAIL;
+	      break;
+	    }
+	  /* FALLTHRU */
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	  switch (form2)
+	    {
+	    case DW_FORM_ref_addr:
+	      if (likely (!op_multifile && !rd_multifile && !fi_multifile))
+		FAIL;
+	      break;
+	    case DW_FORM_ref_udata:
+	    case DW_FORM_ref1:
+	    case DW_FORM_ref2:
+	    case DW_FORM_ref4:
+	    case DW_FORM_ref8:
+	      break;
+	    default:
+	      FAIL;
+	    }
+	  break;
+	default:
+	  if (form1 != form2)
+	    FAIL;
+	  break;
+	}
+
+      switch (form1)
+	{
+	case DW_FORM_addr:
+	  ptr1 += ptr_size;
+	  ptr2 += ptr_size;
+	  break;
+	case DW_FORM_flag_present:
+	  break;
+	case DW_FORM_implicit_const:
+	  if ((!ignore_locus || old_ptr1) && t1->values[i] != t2->values[j])
+	    FAIL;
+	  break;
+	case DW_FORM_flag:
+	case DW_FORM_data1:
+	  ++ptr1;
+	  ++ptr2;
+	  break;
+	case DW_FORM_data2:
+	  ptr1 += 2;
+	  ptr2 += 2;
+	  break;
+	case DW_FORM_data4:
+	case DW_FORM_sec_offset:
+	  ptr1 += 4;
+	  ptr2 += 4;
+	  break;
+	case DW_FORM_data8:
+	case DW_FORM_ref_sig8:
+	  ptr1 += 8;
+	  ptr2 += 8;
+	  break;
+	case DW_FORM_data16:
+	  ptr1 += 16;
+	  ptr2 += 16;
+	  break;
+	case DW_FORM_sdata:
+	case DW_FORM_udata:
+	  skip_leb128 (ptr1);
+	  skip_leb128 (ptr2);
+	  break;
+	case DW_FORM_strp:
+	  if (unlikely (op_multifile || rd_multifile || fi_multifile))
+	    {
+	      value1 = read_32 (ptr1);
+	      value2 = read_32 (ptr2);
+	      if (fi_multifile)
+		{
+		  if (strcmp ((char *) (cu1->cu_kind == CU_ALT
+					? alt_data[DEBUG_STR]
+					: debug_sections[DEBUG_STR].data)
+			      + value1,
+			      (char *) (cu2->cu_kind == CU_ALT
+					? alt_data[DEBUG_STR]
+					: debug_sections[DEBUG_STR].data)
+			      + value2) != 0)
+		    FAIL;
+		  i++;
+		  j++;
+		  continue;
+		}
+	      if (strcmp ((char *) debug_sections[DEBUG_STR].data + value1,
+			  (char *) debug_sections[DEBUG_STR].data + value2)
+		  != 0)
+		FAIL;
+	      i++;
+	      j++;
+	      continue;
+	    }
+	  ptr1 += 4;
+	  ptr2 += 4;
+	  break;
+	case DW_FORM_line_strp:
+	  ptr1 += 4;
+	  ptr2 += 4;
+	  break;
+	case DW_FORM_string:
+	  ptr1 = (unsigned char *) strchr ((char *)ptr1, '\0') + 1;
+	  ptr2 = (unsigned char *) strchr ((char *)ptr2, '\0') + 1;
+	  break;
+	case DW_FORM_indirect:
+	  abort ();
+	case DW_FORM_block1:
+	  len = *ptr1++;
+	  ptr1 += len;
+	  len = *ptr2++;
+	  ptr2 += len;
+	  break;
+	case DW_FORM_block2:
+	  len = read_16 (ptr1);
+	  ptr1 += len;
+	  len = read_16 (ptr2);
+	  ptr2 += len;
+	  break;
+	case DW_FORM_block4:
+	  len = read_32 (ptr1);
+	  ptr1 += len;
+	  len = read_32 (ptr2);
+	  ptr2 += len;
+	  break;
+	case DW_FORM_block:
+	case DW_FORM_exprloc:
+	  len = read_uleb128 (ptr1);
+	  ptr1 += len;
+	  len = read_uleb128 (ptr2);
+	  ptr2 += len;
+	  break;
+	case DW_FORM_ref_addr:
+	  if (likely (!op_multifile && !rd_multifile && !fi_multifile))
+	    {
+	      ptr1 += cu1->cu_version == 2 ? ptr_size : 4;
+	      ptr2 += cu2->cu_version == 2 ? ptr_size : 4;
+	      break;
+	    }
+	  /* FALLTHRU */
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	  switch (form1)
+	    {
+	    case DW_FORM_ref_addr:
+	      value1 = read_size (ptr1, cu1->cu_version == 2
+					? ptr_size : 4)
+		       - cu1->cu_offset;
+	      ptr1 += cu1->cu_version == 2 ? ptr_size : 4;
+	      break;
+	    case DW_FORM_ref_udata:
+	      value1 = read_uleb128 (ptr1);
+	      break;
+	    case DW_FORM_ref1:
+	      value1 = read_8 (ptr1);
+	      break;
+	    case DW_FORM_ref2:
+	      value1 = read_16 (ptr1);
+	      break;
+	    case DW_FORM_ref4:
+	      value1 = read_32 (ptr1);
+	      break;
+	    case DW_FORM_ref8:
+	      value1 = read_64 (ptr1);
+	      break;
+	    default: abort ();
+	    }
+	  ref1 = off_htab_lookup (cu1, cu1->cu_offset + value1);
+	  switch (form2)
+	    {
+	    case DW_FORM_ref_addr:
+	      value2 = read_size (ptr2, cu2->cu_version == 2
+					? ptr_size : 4)
+		       - cu2->cu_offset;
+	      ptr2 += cu2->cu_version == 2 ? ptr_size : 4;
+	      break;
+	    case DW_FORM_ref_udata:
+	      value2 = read_uleb128 (ptr2);
+	      break;
+	    case DW_FORM_ref1:
+	      value2 = read_8 (ptr2);
+	      break;
+	    case DW_FORM_ref2:
+	      value2 = read_16 (ptr2);
+	      break;
+	    case DW_FORM_ref4:
+	      value2 = read_32 (ptr2);
+	      break;
+	    case DW_FORM_ref8:
+	      value2 = read_64 (ptr2);
+	      break;
+	    default: abort ();
+	    }
+	  ref2 = off_htab_lookup (cu2, cu2->cu_offset + value2);
+	  assert (ref1 != NULL && ref2 != NULL);
+	  if (unlikely (op_multifile || low_mem))
+	    {
+	      if (die1->die_collapsed_children && ref1->die_collapsed_child)
+		{
+		  expand_child (die1, true);
+		  ref1 = off_htab_lookup (cu1, cu1->cu_offset + value1);
+		}
+	      assert (ref2->die_collapsed_child == 0);
+	    }
+	  if (likely (!ref1->die_collapsed_child)
+	      && die_cu (ref1) == cu1
+	      && ref1->u.p1.die_enter >= top_die1->u.p1.die_enter
+	      && ref1->u.p1.die_exit <= top_die1->u.p1.die_exit)
+	    {
+	      /* A reference into a subdie of the DIE being compared.  */
+	      if (die_cu (ref2) != cu2
+		  || ref1->u.p1.die_enter - top_die1->u.p1.die_enter
+		     != ref2->u.p1.die_enter - top_die2->u.p1.die_enter
+		  || top_die1->u.p1.die_exit - ref1->u.p1.die_exit
+		     != top_die2->u.p1.die_exit - ref2->u.p1.die_exit)
+		FAIL;
+	    }
+	  else
+	    {
+	      dw_die_ref reft1 = ref1, reft2 = ref2;
+	      dw_cu_ref refcu1, refcu2;
+	      while (reft1->die_toplevel == 0)
+		reft1 = reft1->die_parent;
+	      while (reft2->die_toplevel == 0)
+		reft2 = reft2->die_parent;
+	      if (unlikely (ref1->die_collapsed_child))
+		{
+		  if (ref1->die_tag
+		      != ref2->u.p1.die_enter - reft2->u.p1.die_enter)
+		    FAIL;
+		}
+	      else if (ref1->u.p1.die_enter - reft1->u.p1.die_enter
+		       != ref2->u.p1.die_enter - reft2->u.p1.die_enter)
+		FAIL;
+	      refcu1 = die_cu (reft1);
+	      refcu2 = die_cu (reft2);
+	      if (unlikely (refcu1->cu_chunk == refcu2->cu_chunk)
+		  && likely (!fi_multifile))
+		{
+		  if (reft1->die_dup
+		      && die_cu (reft1->die_dup)->cu_chunk
+			 == refcu1->cu_chunk)
+		    reft1 = reft1->die_dup;
+		  if (reft2->die_dup
+		      && die_cu (reft2->die_dup)->cu_chunk
+			 == refcu2->cu_chunk)
+		    reft2 = reft2->die_dup;
+		  if (reft2->die_offset < reft1->die_offset)
+		    {
+		      dw_die_ref tem = reft1;
+		      reft1 = reft2;
+		      reft2 = tem;
+		    }
+		  if (reft1->die_dup == NULL && reft2->die_dup != NULL)
+		    {
+		      dw_die_ref tem = reft1;
+		      reft1 = reft2;
+		      reft2 = tem;
+		    }
+		}
+	      /* If reft1 (die1 or whatever refers to it is already
+		 in the hash table) already has a dup, follow to that
+		 dup.  Don't do the same for reft2, {{top_,}die,reft,child}2
+		 should always be from the current CU.  */
+	      if (reft1->die_dup)
+		reft1 = reft1->die_dup;
+	      refcu1 = die_cu (reft1);
+	      refcu2 = die_cu (reft2);
+	      if (die_eq_1 (refcu1, refcu2, reft1, reft2, reft1, reft2) == 0)
+		FAIL;
+	    }
+	  i++;
+	  j++;
+	  continue;
+	default:
+	  abort ();
+	}
+
+      if ((!ignore_locus || old_ptr1)
+	  && (ptr1 - old_ptr1 != ptr2 - old_ptr2
+	      || memcmp (old_ptr1, old_ptr2, ptr1 - old_ptr1)))
+	FAIL;
+      i++;
+      j++;
+    }
+
+  if (unlikely (op_multifile || low_mem))
+    {
+      if (die1->die_collapsed_children)
+	expand_child (die1, true);
+      assert (die2->die_collapsed_children == 0);
+    }
+
+  for (child1 = die1->die_child, child2 = die2->die_child;
+       child1 && child2;
+       child1 = child1->die_sib, child2 = child2->die_sib)
+    if (die_eq_1 (cu1, cu2, top_die1, top_die2, child1, child2) == 0)
+      FAIL;
+
+  if (child1 || child2)
+    {
+    fail:
+      return 0;
+    }
+
+  if (unlikely (fi_multifile))
+    assert (cu1->cu_kind == CU_ALT && cu2->cu_kind != CU_ALT);
+  return 1;
+}
+
+/* Wrapper around die_eq_1, used as equality function in
+   dup_htab hash table.  If zero (non-match) is returned and
+   any toplevel DIEs have been pushed to the vector in ob obstack,
+   undo the optimistic assignment of die_dup and die_nextdup.  */
+static int
+die_eq (const void *p, const void *q)
+{
+  dw_die_ref die1 = (dw_die_ref) p;
+  dw_die_ref die2 = (dw_die_ref) q;
+  dw_die_ref *arr;
+  unsigned int i, count;
+  int ret;
+
+  if (die1->u.p1.die_hash != die2->u.p1.die_hash
+      || die1->u.p1.die_ref_hash != die2->u.p1.die_ref_hash)
+    return 0;
+  ret = die_eq_1 (die_cu (die1), die_cu (die2), die1, die2, die1, die2);
+  count = obstack_object_size (&ob) / sizeof (void *);
+  arr = (dw_die_ref *) obstack_finish (&ob);
+  if (!ret)
+    for (i = count; i;)
+      {
+	dw_die_ref die;
+	i -= 2;
+	die = arr[i]->die_dup;
+	if (likely (arr[i + 1] == NULL))
+	  {
+	    die->die_nextdup = arr[i]->die_nextdup;
+	    arr[i]->die_nextdup = NULL;
+	    arr[i]->die_dup = NULL;
+	  }
+	else
+	  {
+	    dw_die_ref next;
+
+	    assert (die->die_nextdup == arr[i]);
+	    for (next = arr[i]->die_nextdup;
+		 next != arr[i + 1];
+		 next = next->die_nextdup)
+	      {
+		assert (next->die_dup == die);
+		next->die_dup = arr[i];
+	      }
+	    assert (next->die_dup == die);
+	    next->die_dup = arr[i];
+	    die->die_nextdup = next->die_nextdup;
+	    next->die_nextdup = NULL;
+	    arr[i]->die_dup = NULL;
+	  }
+	arr[i]->die_remove = 0;
+      }
+  obstack_free (&ob, (void *) arr);
+  return ret;
+}
+
+/* Hash table for finding of matching toplevel DIEs (and all
+   its children together with it).  */
+static htab_t dup_htab;
+
+/* After read_multifile dup_htab is moved to this variable.  */
+static htab_t alt_dup_htab;
+
+/* First CU, start of the linked list of CUs, and the tail
+   of that list.  Initially this contains just the original
+   CUs, later on newly created partial units are added
+   to the beginning of the list and optionally .debug_types
+   CUs are added to its tail.  */
+static dw_cu_ref first_cu, last_cu;
+
+/* After read_multifile first_cu is copied to this variable.  */
+static dw_cu_ref alt_first_cu;
+
+/* Compute approximate size of DIE and all its children together.  */
+static unsigned long
+calc_sizes (dw_die_ref die)
+{
+  unsigned long ret = die->die_size;
+  dw_die_ref child;
+  if (wr_multifile ? die->die_no_multifile : die->die_remove)
+    return 0;
+  for (child = die->die_child; child; child = child->die_sib)
+    ret += calc_sizes (child);
+  return ret;
+}
+
+/* Verify the duplicate chains starting at DIE.  If ORDERED, also check that
+   the duplicate chain is in the correct order.  */
+static void
+verify_dups (dw_die_ref die, bool ordered)
+{
+  dw_die_ref d, prev;
+
+  assert (die->die_dup == NULL);
+  assert (die->die_collapsed_children == 0);
+  assert (die->die_remove == 0);
+
+  for (prev = die, d = prev->die_nextdup;
+       d;
+       prev = d, d = prev->die_nextdup)
+    {
+      if (ordered)
+	assert (die_cu (prev)->cu_chunk <= die_cu (d)->cu_chunk);
+      assert (d->die_offset != -1U);
+      assert (d->die_dup == die);
+      assert (d->die_remove != d->die_op_type_referenced);
+      assert (d->die_tag == die->die_tag);
+    }
+}
+
+/* Walk toplevel DIEs in tree rooted by PARENT, and see if they
+   match previously processed DIEs.  */
+static int
+find_dups (dw_die_ref parent)
+{
+  void **slot;
+  dw_die_ref child;
+
+  if (stats_p && parent->die_root)
+    stats->root_cnt++;
+
+  for (child = parent->die_child; child; child = child->die_sib)
+    {
+      if (child->die_ck_state == CK_KNOWN)
+	{
+	  if (stats_p)
+	    stats->lower_toplevel_with_checksum++;
+	  if (child->die_dup != NULL)
+	    continue;
+	  slot = htab_find_slot_with_hash (dup_htab, child,
+					   child->u.p1.die_ref_hash,
+					   INSERT);
+	  if (slot == NULL)
+	    dwz_oom ();
+	  if (*slot == NULL)
+	    *slot = child;
+	}
+      else if (child->die_named_namespace)
+	{
+	  if (stats_p)
+	    stats->namespace_cnt++;
+	  if (find_dups (child))
+	    return 1;
+	}
+      else if (stats_p)
+	stats->lower_toplevel++;
+    }
+  return 0;
+}
+
+/* Like find_dups, but for the last multifile optimization phase,
+   where it only looks at duplicates in the common .debug_info
+   section.  */
+static int
+find_dups_fi (dw_die_ref parent)
+{
+  dw_die_ref child;
+
+  for (child = parent->die_child; child; child = child->die_sib)
+    {
+      if (child->die_ck_state == CK_KNOWN)
+	{
+	  if (child->die_dup != NULL)
+	    continue;
+	  htab_find_with_hash (alt_dup_htab, child, child->u.p1.die_ref_hash);
+	}
+      else if (child->die_named_namespace)
+	if (find_dups_fi (child))
+	  return 1;
+    }
+  return 0;
+}
+
+/* Return value of DW_AT_name for DIE, or for its specification or abstract
+   origin.  */
+static const char *
+get_name (dw_die_ref die)
+{
+  if (die->die_collapsed_child)
+    return NULL;
+  const char *name = get_AT_string (die, DW_AT_name);
+  if (name)
+    return name;
+  dw_cu_ref cu = die_cu (die);
+  bool present;
+  enum dwarf_form form;
+  unsigned int value = get_AT_int (die, DW_AT_specification, &present, &form);
+  if (present)
+    {
+      dw_die_ref ref;
+      if (form != DW_FORM_ref_addr)
+	value = cu->cu_offset + value;
+      ref = off_htab_lookup (cu, value);
+      if (ref)
+	return get_name (ref);
+    }
+  value = get_AT_int (die, DW_AT_abstract_origin, &present, &form);
+  if (present)
+    {
+      dw_die_ref ref;
+      if (form != DW_FORM_ref_addr)
+	value = cu->cu_offset + value;
+      ref = off_htab_lookup (die_cu (die), value);
+      if (ref)
+	return get_name (ref);
+    }
+  return NULL;
+}
+
+/* Dump type of DIE to stderr.  */
+static void
+dump_type (dw_die_ref die)
+{
+  bool present;
+  enum dwarf_form form;
+  if (die->die_collapsed_child)
+    return;
+  unsigned int value = get_AT_int (die, DW_AT_type, &present, &form);
+  if (!present)
+    return;
+
+  dw_cu_ref cu = die_cu (die);
+  if (cu == NULL)
+    return;
+
+  dw_die_ref ref;
+  if (form != DW_FORM_ref_addr)
+    value = cu->cu_offset + value;
+  fprintf (stderr, " (type: %x", value);
+  ref = off_htab_lookup (cu, value);
+  if (ref != NULL && !ref->die_collapsed_child)
+    {
+      const char *type_name = get_name (ref);
+      if (type_name)
+	fprintf (stderr, " %s", type_name);
+      fprintf (stderr, " %s", get_DW_TAG_name (ref->die_tag) + 7);
+      dump_type (ref);
+    }
+  fprintf (stderr, ")");
+}
+
+/* Dump DIE to stderr with INDENT.  */
+static void
+dump_die_with_indent (int indent, dw_die_ref die)
+{
+  if (die == NULL)
+    fprintf (stderr, "%*s null", indent, "");
+  else if (die->die_offset == -1U)
+    {
+      fprintf (stderr, "%*s -1 %s", indent, "",
+	       get_DW_TAG_name (die->die_tag) + 7);
+      dw_die_ref d = die->die_nextdup;
+      while (d)
+	{
+	  const char *name = get_name (d);
+	  fprintf (stderr, " -> %x %s %s", d->die_offset, name ? name : "",
+		   get_DW_TAG_name (d->die_tag) + 7);
+	  d = d->die_nextdup;
+	}
+    }
+  else if (die->die_collapsed_child)
+    {
+      fprintf (stderr, "%*s %x %c", indent, "", die->die_offset,
+	   die->die_ck_state == CK_KNOWN ? 'O' : 'X');
+    }
+  else
+    {
+      const char *name = get_name (die);
+      fprintf (stderr, "%*s %x %c %x", indent, "", die->die_offset,
+	       die->die_ck_state == CK_KNOWN ? 'O' : 'X',
+	       (unsigned) die->u.p1.die_hash);
+      if (odr && die->die_odr_state != ODR_NONE
+	   && die->die_odr_state != ODR_UNKNOWN)
+	  fprintf (stderr, "(%x)", (unsigned) die->u.p1.die_hash2);
+      fprintf (stderr, " %x %s %s", (unsigned) die->u.p1.die_ref_hash,
+	       name ? name : "", get_DW_TAG_name (die->die_tag) + 7);
+      dump_type (die);
+    }
+  fprintf (stderr, "\n");
+}
+
+/* Dump DIE to stderr.  */
+static void
+dump_die (dw_die_ref die)
+{
+  dump_die_with_indent (0, die);
+}
+
+static void
+dump_dups (dw_die_ref die)
+{
+  dw_die_ref d;
+  for (d = die; d; d = d->die_nextdup)
+    dump_die (d);
+}
+
+/* Dump DIE tree at tree depth DEPTH.  */
+static void
+dump_dies (int depth, dw_die_ref die)
+{
+  dw_die_ref child;
+  dump_die_with_indent (depth, die);
+  for (child = die->die_child; child; child = child->die_sib)
+    dump_dies (depth + 1, child);
+}
+
+/* Hash table for .debug_str.  Depending on multifile optimization
+   phase this hash table has 3 different hash/equality functions.
+   The first set is used to record tail optimized strings, during
+   write_multifile the whole .debug_str section is written as is,
+   plus then all the strings which are just suffixes of other
+   strings.  E.g. if .debug_str section contains "foobar" string
+   and .debug_info section refers to the whole "foobar" string
+   as well as "bar" by referring to "foobar" + 3.
+   The second set is used during op_multifile and fi_multifile,
+   noting each string and in addition to that how many times it
+   has been seen (0, 1 or more than 1).  If 0 then it isn't present
+   in the hash table, 1 has lowest bit of new_off clear, more than 1
+   the LSB of new_off is set.
+   The final set is used during finalize_strp and afterwards, it is
+   then used to map strings to their location in the new .debug_str
+   section.  */
+static htab_t strp_htab;
+/* Current offset in .debug_str when adding the tail optimized strings.
+   This is initially the size of .debug_str section in the object,
+   and as unique tail optimized strings are found, this is increased
+   each time.  */
+static unsigned int max_strp_off;
+
+/* At the end of read_multifile strp_htab is moved to this variable,
+   which is used to find strings in the shared .debug_str section.  */
+static htab_t alt_strp_htab;
+
+/* Structure describing strings in strp_htab.  */
+struct strp_entry
+{
+  /* Original .debug_str offset.  */
+  unsigned int off;
+  /* New .debug_str offset, or when using strp_{hash,eq}2
+     this is initially iterative hash of the string with the
+     LSB bit used for whether the string has been seen just once
+     or more than once.  */
+  unsigned int new_off;
+};
+ALIGN_STRUCT (strp_entry)
+
+/* Hash function in strp_htab used for discovery of tail optimized
+   strings.  */
+static hashval_t
+strp_hash (const void *p)
+{
+  struct strp_entry *s = (struct strp_entry *)p;
+
+  return s->off;
+}
+
+/* Corresponding equality function in strp_htab.  */
+static int
+strp_eq (const void *p, const void *q)
+{
+  struct strp_entry *s1 = (struct strp_entry *)p;
+  struct strp_entry *s2 = (struct strp_entry *)q;
+
+  return s1->off == s2->off;
+}
+
+/* Hash function in strp_htab used to find what strings are
+   used by more than one object.  */
+static hashval_t
+strp_hash2 (const void *p)
+{
+  struct strp_entry *s = (struct strp_entry *)p;
+
+  return s->new_off & ~1U;
+}
+
+/* Corresponding equality function in strp_htab.  */
+static int
+strp_eq2 (const void *p, const void *q)
+{
+  struct strp_entry *s1 = (struct strp_entry *)p;
+  struct strp_entry *s2 = (struct strp_entry *)q;
+
+  return strcmp ((char *) debug_sections[DEBUG_STR].data + s1->off,
+		 (char *) debug_sections[DEBUG_STR].data + s2->off) == 0;
+}
+
+/* Hash function in strp_htab used from finalize_strp onwards,
+   mapping strings into strings in the new .debug_str section.  */
+static hashval_t
+strp_hash3 (const void *p)
+{
+  return hash (p, strlen (p));
+}
+
+/* Corresponding equality function in strp_htab.  */
+static int
+strp_eq3 (const void *p, const void *q)
+{
+  return strcmp (p, q) == 0;
+}
+
+/* Called for each DW_FORM_strp offset seen during initial
+   .debug_{info,types,macro} parsing.  Before fi_multifile phase
+   this records just tail optimized strings, during fi_multifile
+   it checks whether the string is already in the shared .debug_str
+   section and if not, notes that it will need to be added to the
+   new local .debug_str section.  */
+static void
+note_strp_offset (unsigned int off)
+{
+  void **slot;
+  struct strp_entry se;
+
+  if (unlikely (fi_multifile))
+    {
+      unsigned char *p;
+      unsigned int len;
+      hashval_t hash;
+
+      p = debug_sections[DEBUG_STR].data + off;
+      len = strlen ((char *) p);
+      hash = hash (p, len);
+      if (alt_strp_htab)
+	{
+	  if (htab_find_with_hash (alt_strp_htab, p, hash))
+	    return;
+	}
+      if (strp_htab == NULL)
+	{
+	  unsigned int strp_count = debug_sections[DEBUG_STR].size / 64;
+
+	  if (strp_count < 100)
+	    strp_count = 100;
+	  strp_htab = htab_try_create (strp_count, strp_hash2, strp_eq2, NULL);
+	  if (strp_htab == NULL)
+	    dwz_oom ();
+	}
+
+      se.off = off;
+      se.new_off = hash | 1;
+      slot = htab_find_slot_with_hash (strp_htab, &se, se.new_off & ~1U, INSERT);
+      if (slot == NULL)
+	dwz_oom ();
+      if (*slot == NULL)
+	{
+	  struct strp_entry *s = pool_alloc (strp_entry, sizeof (*s));
+	  *s = se;
+	  *slot = (void *) s;
+	}
+      return;
+    }
+  if (off >= debug_sections[DEBUG_STR].size || off == 0)
+    return;
+  if (debug_sections[DEBUG_STR].data[off - 1] == '\0')
+    return;
+  if (strp_htab == NULL)
+    {
+      if (multifile == NULL)
+	return;
+      strp_htab = htab_try_create (50, strp_hash, strp_eq, NULL);
+      if (strp_htab == NULL)
+	dwz_oom ();
+      max_strp_off = debug_sections[DEBUG_STR].size;
+    }
+  se.off = off;
+  slot = htab_find_slot_with_hash (strp_htab, &se, off, INSERT);
+  if (slot == NULL)
+    dwz_oom ();
+  if (*slot == NULL)
+    {
+      struct strp_entry *s = pool_alloc (strp_entry, sizeof (*s));
+      s->off = off;
+      s->new_off = max_strp_off;
+      max_strp_off += strlen ((char *) debug_sections[DEBUG_STR].data
+			      + off) + 1;
+      if (max_strp_off < s->new_off)
+	{
+	  htab_delete (strp_htab);
+	  strp_htab = NULL;
+	  max_strp_off = 0;
+	  multifile = NULL;
+	  error (0, 0, ".debug_str too large for multi-file optimization");
+	}
+      *slot = (void *) s;
+    }
+}
+
+/* Map offset in original .debug_str section into
+   offset in new .debug_str, either the shared .debug_str
+   or new local .debug_str.  */
+static unsigned
+lookup_strp_offset (unsigned int off)
+{
+  struct strp_entry *s, se;
+
+  if (unlikely (op_multifile || fi_multifile))
+    {
+      unsigned char *p;
+      unsigned int len;
+      hashval_t hash;
+
+      p = debug_sections[DEBUG_STR].data + off;
+      len = strlen ((char *) p);
+      hash = hash (p, len);
+      if (alt_strp_htab)
+	{
+	  unsigned char *q = (unsigned char *)
+			     htab_find_with_hash (alt_strp_htab, p, hash);
+	  if (q != NULL)
+	    return q - alt_data[DEBUG_STR];
+	}
+      assert (strp_htab);
+      p = (unsigned char *) htab_find_with_hash (strp_htab, p, hash);
+      assert (p != NULL);
+      return p - debug_sections[DEBUG_STR].new_data;
+    }
+  if (off >= debug_sections[DEBUG_STR].size || off == 0)
+    return off + multi_str_off;
+  if (debug_sections[DEBUG_STR].data[off - 1] == '\0')
+    return off + multi_str_off;
+  se.off = off;
+  s = (struct strp_entry *) htab_find_with_hash (strp_htab, &se, off);
+  return s->new_off + multi_str_off;
+}
+
+/* Note .debug_str offset during write_macro or compute_abbrevs,
+   return either DW_FORM_strp if the string will be in the local
+   .debug_str section, or DW_FORM_strp_sup / DW_FORM_GNU_strp_alt if it
+   will be in the shared .debug_str section.  */
+static enum dwarf_form
+note_strp_offset2 (unsigned int off)
+{
+  hashval_t hash;
+  struct strp_entry se;
+  unsigned char *p, *q;
+
+  if (likely (fi_multifile))
+    {
+      unsigned int len;
+
+      if (alt_strp_htab)
+	{
+	  p = debug_sections[DEBUG_STR].data + off;
+	  len = strlen ((char *) p);
+	  hash = hash (p, len);
+	  if (htab_find_with_hash (alt_strp_htab, p, hash))
+	    return dwarf_5 ? DW_FORM_strp_sup : DW_FORM_GNU_strp_alt;
+	}
+      return DW_FORM_strp;
+    }
+  if (off >= debug_sections[DEBUG_STR].size)
+    return DW_FORM_strp;
+  p = debug_sections[DEBUG_STR].data + off;
+  q = (unsigned char *) strchr ((char *) p, '\0');
+  hash = hash (p, q - p);
+  se.off = off;
+  se.new_off = hash & ~1U;
+  struct strp_entry *s = (struct strp_entry *)
+			 htab_find_with_hash (strp_htab, &se, se.new_off);
+  assert (s != NULL);
+  s->new_off |= 1;
+  return DW_FORM_strp;
+}
+
+/* Helper to record all strp_entry entries from strp_htab.
+   Called through htab_traverse.  */
+static int
+list_strp_entries (void **slot, void *data)
+{
+  struct strp_entry ***end = (struct strp_entry ***) data;
+  **end = (struct strp_entry *) *slot;
+  (*end)++;
+  return 1;
+}
+
+/* Adapted from bfd/merge.c strrevcmp.  */
+static int
+strrevcmp (const void *p, const void *q)
+{
+  struct strp_entry *s1 = *(struct strp_entry **)p;
+  struct strp_entry *s2 = *(struct strp_entry **)q;
+  unsigned int len1 = s1->new_off & ~1U;
+  unsigned int len2 = s2->new_off & ~1U;
+  unsigned int len;
+  unsigned char *p1 = debug_sections[DEBUG_STR].data + s1->off;
+  unsigned char *p2 = debug_sections[DEBUG_STR].data + s2->off;
+
+  if (p1[len1])
+    len1++;
+  if (p2[len2])
+    len2++;
+  p1 += len1;
+  p2 += len2;
+  len = len1;
+  if (len2 < len)
+    len = len2;
+  while (len)
+    {
+      p1--;
+      p2--;
+      if (*p1 != *p2)
+	{
+	  if (*p1 < *p2)
+	    return -1;
+	  return 1;
+	}
+      len--;
+    }
+  if (len1 < len2)
+    return 1;
+  if (len1 > len2)
+    return -1;
+  assert (s1->off == s2->off);
+  return 0;
+}
+
+/* Compute new .debug_str section, from strp_htab content,
+   replace strp_htab hash table with a new one, which maps strings
+   to new .debug_str locations.  */
+static unsigned int *
+finalize_strp (bool build_tail_offset_list)
+{
+  unsigned int count, new_count, i, *tail_offset_list = NULL;
+  unsigned int strp_index = 0, tail_offset_list_count = 0, k;
+  struct strp_entry **arr, **end;
+  unsigned char *p;
+
+  if (strp_htab == NULL)
+    {
+      debug_sections[DEBUG_STR].new_data = NULL;
+      debug_sections[DEBUG_STR].new_size = 0;
+      return NULL;
+    }
+  count = htab_elements (strp_htab);
+  arr = (struct strp_entry **)
+	obstack_alloc (&ob, count * sizeof (struct strp_entry *));
+  end = arr;
+  htab_traverse (strp_htab, list_strp_entries, (void *) &end);
+  for (i = 0; i < count; i++)
+    {
+      unsigned int len = strlen ((char *) debug_sections[DEBUG_STR].data
+				 + arr[i]->off);
+      arr[i]->new_off = (len & ~1U) | (arr[i]->new_off & 1);
+    }
+  qsort (arr, count, sizeof (struct strp_entry *), strrevcmp);
+  htab_delete (strp_htab);
+  strp_htab = NULL;
+  new_count = count;
+  for (i = 0; i < count; i++)
+    if ((arr[i]->new_off & 1) == 0)
+      {
+	arr[i]->off = -1U;
+	arr[i]->new_off = -1U;
+	new_count--;
+      }
+    else
+      {
+	unsigned int len1, len2, lastlen, j;
+	unsigned char *p1, *p2;
+	len1 = arr[i]->new_off & ~1U;
+	p1 = debug_sections[DEBUG_STR].data + arr[i]->off;
+	if (p1[len1])
+	  len1++;
+	lastlen = len1;
+	arr[i]->new_off = strp_index;
+	strp_index += len1 + 1;
+	for (j = i + 1; j < count; j++)
+	  {
+	    len2 = arr[j]->new_off & ~1U;
+	    p2 = debug_sections[DEBUG_STR].data + arr[j]->off;
+	    if (p2[len2])
+	      len2++;
+	    if (len2 >= lastlen)
+	      break;
+	    if (memcmp (p1 + len1 - len2, p2, len2 + 1) != 0)
+	      break;
+	    arr[j]->new_off = arr[i]->new_off + len1 - len2;
+	    lastlen = len2;
+	    tail_offset_list_count++;
+	  }
+	i = j - 1;
+      }
+  debug_sections[DEBUG_STR].new_data = malloc (strp_index);
+  if (debug_sections[DEBUG_STR].new_data == NULL)
+    dwz_oom ();
+  debug_sections[DEBUG_STR].new_size = strp_index;
+  strp_htab = htab_try_create (new_count < 32 ? 32 : new_count,
+			       strp_hash3, strp_eq3, NULL);
+  if (strp_htab == NULL)
+    dwz_oom ();
+  if (build_tail_offset_list && tail_offset_list_count++ != 0)
+    {
+      tail_offset_list
+	= mmap (NULL, tail_offset_list_count * sizeof (int),
+		PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+      if (tail_offset_list == MAP_FAILED)
+	dwz_oom ();
+    }
+  for (i = 0, k = 0, p = debug_sections[DEBUG_STR].new_data; i < count; i++)
+    if (arr[i]->off == -1U && arr[i]->new_off == -1U)
+      continue;
+    else
+      {
+	unsigned int len = strlen ((char *) debug_sections[DEBUG_STR].data
+				   + arr[i]->off) + 1;
+	unsigned int j;
+	void **slot;
+
+	memcpy (p, debug_sections[DEBUG_STR].data + arr[i]->off, len);
+	slot = htab_find_slot_with_hash (strp_htab, p,
+					 hash (p, len - 1),
+					 INSERT);
+	if (slot == NULL)
+	  dwz_oom ();
+	assert (*slot == NULL);
+	*slot = (void *) p;
+	for (j = i + 1; j < count; j++)
+	  if (arr[j]->new_off >= arr[i]->new_off + len)
+	    break;
+	  else
+	    {
+	      unsigned char *q = p + arr[j]->new_off - arr[i]->new_off;
+	      unsigned int l = len + arr[i]->new_off - arr[j]->new_off;
+	      if (tail_offset_list != NULL)
+		tail_offset_list[k++] = arr[j]->new_off;
+	      slot = htab_find_slot_with_hash (strp_htab, q,
+					       hash (q, l - 1),
+					       INSERT);
+	      if (slot == NULL)
+		dwz_oom ();
+	      assert (*slot == NULL);
+	      *slot = (void *) q;
+	    }
+	p += len;
+	i = j - 1;
+      }
+  assert (p == debug_sections[DEBUG_STR].new_data + strp_index);
+  if (tail_offset_list != NULL)
+    {
+      tail_offset_list[k++] = 0;
+      assert (k == tail_offset_list_count);
+    }
+  obstack_free (&ob, (void *) arr);
+  return tail_offset_list;
+}
+
+enum mark_refs_mode
+{
+  MARK_REFS_FOLLOW_DUPS = 1,
+  MARK_REFS_RETURN_VAL = 2,
+  MARK_REFS_REFERENCED = 4
+};
+
+/* Mark all DIEs referenced from DIE by setting die_ref_seen to 1,
+   unless already marked.  */
+static bool
+mark_refs (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die, int mode)
+{
+  struct abbrev_tag *t;
+  unsigned int i;
+  unsigned char *ptr;
+  dw_die_ref child;
+
+  t = die->die_abbrev;
+  for (i = 0; i < t->nattr; ++i)
+    if (t->attr[i].attr != DW_AT_sibling)
+      switch (t->attr[i].form)
+	{
+	case DW_FORM_ref_addr:
+	  if (unlikely (op_multifile))
+	    i = -2U;
+	  break;
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	case DW_FORM_indirect:
+	  i = -2U;
+	  break;
+	}
+  if (i == -1U)
+    {
+      if (unlikely (cu->cu_kind == CU_TYPES))
+	ptr = debug_sections[DEBUG_TYPES].data;
+      else
+	ptr = debug_sections[DEBUG_INFO].data;
+      ptr += die->die_offset;
+      skip_leb128 (ptr);
+      for (i = 0; i < t->nattr; ++i)
+	{
+	  uint32_t form = t->attr[i].form;
+	  size_t len = 0;
+	  uint64_t value;
+	  dw_die_ref ref, reft;
+
+	  while (form == DW_FORM_indirect)
+	    form = read_uleb128 (ptr);
+
+	  switch (form)
+	    {
+	    case DW_FORM_ref_addr:
+	      if (unlikely (op_multifile))
+		{
+		  value = read_size (ptr, cu->cu_version == 2
+					  ? ptr_size : 4);
+		  ptr += cu->cu_version == 2 ? ptr_size : 4;
+		  assert (t->attr[i].attr != DW_AT_sibling);
+		  ref = off_htab_lookup (cu, value);
+		  if ((mode & MARK_REFS_REFERENCED) != 0)
+		    ref->die_referenced = 1;
+		  goto finish_ref;
+		}
+	      ptr += cu->cu_version == 2 ? ptr_size : 4;
+	      break;
+	    case DW_FORM_addr:
+	      ptr += ptr_size;
+	      break;
+	    case DW_FORM_flag_present:
+	    case DW_FORM_implicit_const:
+	      break;
+	    case DW_FORM_flag:
+	    case DW_FORM_data1:
+	      ++ptr;
+	      break;
+	    case DW_FORM_data2:
+	      ptr += 2;
+	      break;
+	    case DW_FORM_data4:
+	    case DW_FORM_sec_offset:
+	    case DW_FORM_strp:
+	    case DW_FORM_line_strp:
+	      ptr += 4;
+	      break;
+	    case DW_FORM_data8:
+	    case DW_FORM_ref_sig8:
+	      ptr += 8;
+	      break;
+	    case DW_FORM_data16:
+	      ptr += 16;
+	      break;
+	    case DW_FORM_sdata:
+	    case DW_FORM_udata:
+	      skip_leb128 (ptr);
+	      break;
+	    case DW_FORM_ref_udata:
+	    case DW_FORM_ref1:
+	    case DW_FORM_ref2:
+	    case DW_FORM_ref4:
+	    case DW_FORM_ref8:
+	      switch (form)
+		{
+		case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+		case DW_FORM_ref1: value = read_8 (ptr); break;
+		case DW_FORM_ref2: value = read_16 (ptr); break;
+		case DW_FORM_ref4: value = read_32 (ptr); break;
+		case DW_FORM_ref8: value = read_64 (ptr); break;
+		default: abort ();
+		}
+	      if (t->attr[i].attr == DW_AT_sibling)
+		break;
+	      ref = off_htab_lookup (cu, cu->cu_offset + value);
+	      if ((mode & MARK_REFS_REFERENCED) != 0)
+		ref->die_referenced = 1;
+	      if (!ref->die_collapsed_child
+		  && ref->u.p1.die_enter >= top_die->u.p1.die_enter
+		  && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+		break;
+	    finish_ref:
+	      reft = ref;
+	      while (!reft->die_root
+		     && reft->die_parent->die_tag != DW_TAG_compile_unit
+		     && reft->die_parent->die_tag != DW_TAG_partial_unit
+		     && !reft->die_parent->die_named_namespace)
+		reft = reft->die_parent;
+	      if ((mode & MARK_REFS_FOLLOW_DUPS) && reft->die_dup != NULL)
+		{
+		  reft = reft->die_dup;
+		  if (die_cu (reft)->cu_kind == CU_PU)
+		    break;
+		}
+	      if (reft->die_ref_seen == 0)
+		{
+		  if ((mode & MARK_REFS_RETURN_VAL))
+		    return false;
+		  reft->die_ref_seen = 1;
+		  mark_refs (die_cu (reft), reft, reft, mode);
+		}
+	      break;
+	    case DW_FORM_string:
+	      ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+	      break;
+	    case DW_FORM_indirect:
+	      abort ();
+	    case DW_FORM_block1:
+	      len = *ptr++;
+	      break;
+	    case DW_FORM_block2:
+	      len = read_16 (ptr);
+	      form = DW_FORM_block1;
+	      break;
+	    case DW_FORM_block4:
+	      len = read_32 (ptr);
+	      form = DW_FORM_block1;
+	      break;
+	    case DW_FORM_block:
+	    case DW_FORM_exprloc:
+	      len = read_uleb128 (ptr);
+	      form = DW_FORM_block1;
+	      break;
+	    default:
+	      abort ();
+	    }
+
+	  if (form == DW_FORM_block1)
+	    ptr += len;
+	}
+    }
+
+  for (child = die->die_child; child; child = child->die_sib)
+    if (!mark_refs (cu, top_die, child, mode))
+      return false;
+  return true;
+}
+
+/* Remove completely unneeded children of DIE and remove unreferenced DIEs
+   from offset hash tables.  */
+static void
+remove_dies (dw_cu_ref cu, dw_die_ref die, bool remove)
+{
+  dw_die_ref child, next;
+  if (die->die_toplevel && die->die_ref_seen == 0 && !low_mem)
+    remove = true;
+  for (child = die->die_child; child; child = next)
+    {
+      next = child->die_sib;
+      remove_dies (cu, child, remove);
+    }
+  if (die->die_referenced == 0)
+    {
+      htab_t h = cu->cu_kind == CU_TYPES ? types_off_htab : off_htab;
+      void **slot = htab_find_slot_with_hash (h, die, off_hash (die),
+					      NO_INSERT);
+      if (slot != NULL)
+	htab_clear_slot (h, slot);
+    }
+  if (!remove)
+    return;
+  if (die->die_toplevel == 0)
+    {
+      memset (die, '\0', offsetof (struct dw_die, die_dup));
+      die->die_sib = die_nontoplevel_freelist;
+      die_nontoplevel_freelist = die;
+    }
+  else
+    die->die_child = NULL;
+}
+
+/* Remove unneeded children DIEs.  During phase 0 die_ref_seen
+   of toplevel DIEs is computed, during phase 1 mark_refs is called
+   to find referenced DIEs, during phase 2 unneeded children DIEs
+   are removed.  */
+static void
+remove_unneeded (dw_cu_ref cu, dw_die_ref die, unsigned int phase)
+{
+  dw_die_ref child;
+  for (child = die->die_child; child; child = child->die_sib)
+    {
+      if (child->die_named_namespace)
+	{
+	  remove_unneeded (cu, child, phase);
+	  if (phase == 2)
+	    child->die_ref_seen = 0;
+	}
+      else
+	switch (phase)
+	  {
+	  case 0:
+	    child->die_ref_seen = child->die_dup == NULL;
+	    break;
+	  case 1:
+	    if (child->die_dup == NULL || low_mem)
+	      mark_refs (cu, child, child, MARK_REFS_REFERENCED);
+	    break;
+	  case 2:
+	    remove_dies (cu, child, false);
+	    child->die_ref_seen = 0;
+	    break;
+	  }
+    }
+}
+
+/* Entries in meta_abbrev_htab, mapping .debug_abbrev section offsets
+   to abbrev hash tables.  */
+struct meta_abbrev_entry
+{
+  /* .debug_abbrev offset.  */
+  unsigned int abbrev_off;
+  /* Corresponding hash table.  */
+  htab_t abbrev_htab;
+};
+
+/* Hash table for mapping of .debug_abbrev section offsets to
+   abbrev hash tables.  */
+static htab_t meta_abbrev_htab;
+/* Dummy entry used during OOM handling.  */
+static struct meta_abbrev_entry meta_abbrev_fallback;
+
+/* Hash function for meta_abbrev_htab.  */
+static hashval_t
+meta_abbrev_hash (const void *p)
+{
+  struct meta_abbrev_entry *m = (struct meta_abbrev_entry *)p;
+
+  return m->abbrev_off;
+}
+
+/* Equality function for meta_abbrev_htab.  */
+static int
+meta_abbrev_eq (const void *p, const void *q)
+{
+  struct meta_abbrev_entry *m1 = (struct meta_abbrev_entry *)p;
+  struct meta_abbrev_entry *m2 = (struct meta_abbrev_entry *)q;
+
+  return m1->abbrev_off == m2->abbrev_off;
+}
+
+/* Delete function for meta_abbrev_htab.  */
+static void
+meta_abbrev_del (void *p)
+{
+  struct meta_abbrev_entry *m = (struct meta_abbrev_entry *)p;
+
+  if (m->abbrev_htab != NULL)
+    htab_delete (m->abbrev_htab);
+}
+
+/* Collapse children of TOP_DIE to decrease memory usage.  */
+static void
+collapse_child (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die,
+		unsigned int *tick)
+{
+  dw_die_ref child, next;
+  bool has_children = die->die_child != NULL;
+  unsigned int tick_diff = *tick;
+  for (child = die->die_child; child; child = next)
+    {
+      next = child->die_sib;
+      (*tick)++;
+      collapse_child (cu, top_die, child, tick);
+    }
+  if (has_children)
+    (*tick)++;
+  if (top_die == die)
+    {
+      die->die_child = NULL;
+      die->die_collapsed_children = 1;
+    }
+  else if (die->die_referenced)
+    {
+      die->die_parent = top_die;
+      if (tick_diff <= 0xffff && !die->die_intercu_referenced)
+	{
+	  dw_die_ref ref;
+	  void **slot;
+	  if (die_collapsed_child_freelist)
+	    {
+	      ref = die_collapsed_child_freelist;
+	      die_collapsed_child_freelist = ref->die_parent;
+	    }
+	  else
+	    ref = pool_alloc (dw_die, offsetof (struct dw_die, die_child));
+	  memcpy (ref, die, offsetof (struct dw_die, die_child));
+	  ref->die_collapsed_child = 1;
+	  ref->die_tag = tick_diff;
+	  slot = htab_find_slot_with_hash (cu->cu_kind == CU_TYPES
+					   ? types_off_htab : off_htab,
+					   ref, off_hash (ref), NO_INSERT);
+	  assert (slot != NULL);
+	  *slot = (void *) ref;
+	  memset (die, '\0', offsetof (struct dw_die, die_dup));
+	  die->die_sib = die_nontoplevel_freelist;
+	  die_nontoplevel_freelist = die;
+	}
+      else
+	{
+	  die->die_child = NULL;
+	  die->die_sib = NULL;
+	  die->die_ref_seen = tick_diff;
+	}
+    }
+  else
+    {
+      memset (die, '\0', offsetof (struct dw_die, die_dup));
+      die->die_sib = die_nontoplevel_freelist;
+      die_nontoplevel_freelist = die;
+    }
+}
+
+/* Collapse children of all toplevel DIEs that can be collapsed.  */
+static void
+collapse_children (dw_cu_ref cu, dw_die_ref die)
+{
+  dw_die_ref child;
+  for (child = die->die_child; child; child = child->die_sib)
+    if (child->die_named_namespace)
+      collapse_children (cu, child);
+    else if (child->die_child == NULL)
+      continue;
+    else if (child->die_nextdup == NULL
+	     || (child->die_dup != NULL
+		 && (die_cu (child->die_dup)->cu_kind != CU_PU
+		     || child->die_dup->die_nextdup != child)))
+      {
+	unsigned int tick = 0;
+	collapse_child (cu, child, child, &tick);
+      }
+}
+
+/* Count the number of DIEs in the .debug_info section, and see if we run into
+   some limit.  */
+static int
+try_debug_info (DSO *dso)
+{
+  unsigned char *ptr, *endcu, *endsec;
+  unsigned int value;
+  htab_t abbrev = NULL;
+  unsigned int last_abbrev_offset = 0;
+  struct abbrev_tag tag, *t;
+  unsigned int ndies;
+  unsigned ret = 1;
+  int kind = DEBUG_INFO;
+  bool low_mem_die_limit_hit = false;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "try_debug_info\n");
+    }
+
+  if (tracing)
+    fprintf (stderr, "Counting DIEs\n");
+
+  ndies = 0;
+  ptr = debug_sections[kind].data;
+  endsec = ptr + debug_sections[kind].size;
+  while (ptr < endsec)
+    {
+      unsigned int culen;
+      int cu_version;
+
+      /* Note header is one bigger with DWARF version 5.  */
+      if (ptr + (kind == DEBUG_TYPES ? 23 : 11) > endsec)
+	{
+	  error (0, 0, "%s: %s CU header too small", dso->filename,
+		 debug_sections[kind].name);
+	  goto fail;
+	}
+
+      endcu = ptr + 4;
+      culen = read_32 (ptr);
+      if (culen >= 0xfffffff0)
+	{
+	  error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+	  goto fail;
+	}
+      endcu += culen;
+
+      if (endcu > endsec)
+	{
+	  error (0, 0, "%s: %s too small", dso->filename,
+		 debug_sections[kind].name);
+	  goto fail;
+	}
+
+      cu_version = read_16 (ptr);
+      if (kind == DEBUG_TYPES && (cu_version < 2 || cu_version > 4))
+	{
+	  error (0, 0, "%s: DWARF version %d in .debug_types unhandled",
+		 dso->filename, cu_version);
+	  goto fail;
+	}
+      else if (cu_version < 2 || cu_version > 5)
+	{
+	  error (0, 0, "%s: DWARF version %d in .debug_info unhandled",
+		 dso->filename, cu_version);
+	  goto fail;
+	}
+
+      if (cu_version == 5)
+	{
+	  value = read_8 (ptr);
+	  if (value != DW_UT_compile && value != DW_UT_partial)
+	    error (0, 0, "%s: DWARF CU type %s unhandled", dso->filename,
+		   get_DW_UT_str (value));
+	}
+      else
+	{
+	  value = read_32 (ptr);
+	  if (value >= debug_sections[DEBUG_ABBREV].size)
+	    {
+	      if (debug_sections[DEBUG_ABBREV].data == NULL)
+		error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+	      else
+		error (0, 0, "%s: DWARF CU abbrev offset too large",
+		       dso->filename);
+	      goto fail;
+	    }
+	}
+
+      if (ptr_size == 0)
+	{
+	  ptr_size = read_8 (ptr);
+	  if (ptr_size != 4 && ptr_size != 8)
+	    {
+	      error (0, 0, "%s: Invalid DWARF pointer size %d",
+		     dso->filename, ptr_size);
+	      goto fail;
+	    }
+	}
+      else if (read_8 (ptr) != ptr_size)
+	{
+	  error (0, 0, "%s: DWARF pointer size differs between CUs",
+		 dso->filename);
+	  goto fail;
+	}
+
+      if (cu_version == 5)
+	{
+	  /* Above we only checked for the smaller version 4 header size.  */
+	  if (ptr + 4 > endsec)
+	    {
+	      error (0, 0, "%s: %s CU version 5 header too small",
+		     dso->filename, debug_sections[kind].name);
+	      goto fail;
+	    }
+	  value = read_32 (ptr);
+	  if (value >= debug_sections[DEBUG_ABBREV].size)
+	    {
+	      if (debug_sections[DEBUG_ABBREV].data == NULL)
+		error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+	      else
+		error (0, 0, "%s: DWARF CU abbrev offset too large",
+		       dso->filename);
+	      goto fail;
+	    }
+	}
+
+      if (abbrev == NULL || value != last_abbrev_offset)
+	{
+	  if (abbrev)
+	    htab_delete (abbrev);
+	  abbrev
+	    = read_abbrev (dso, debug_sections[DEBUG_ABBREV].data + value);
+	  if (abbrev == NULL)
+	    {
+	      error (0, 0, "%s: Couldn't read abbrev at offset 0x%x",
+		     dso->filename, value);
+	      goto fail;
+	    }
+	}
+      last_abbrev_offset = value;
+
+      while (ptr < endcu)
+	{
+	  tag.entry = read_uleb128 (ptr);
+	  if (tag.entry == 0)
+	    continue;
+	  if (ndies == max_die_limit)
+	    {
+	      error (0, 0, "%s: Too many DIEs, not optimizing",
+		     dso->filename);
+	      goto fail;
+	    }
+	  /* If we reach the DIE limit, signal the dwz caller that it
+	     should retry with low_mem.  */
+	  if (likely (!low_mem) && ndies == low_mem_die_limit)
+	    {
+	      if (tracing)
+		fprintf (stderr, "Hit low-mem die-limit\n");
+	      if (estimate_nr_dies () > max_die_limit)
+		/* Keep going, we still might hit the max die-limit.  */
+		low_mem_die_limit_hit = true;
+	      else
+		{
+		  ret = 2;
+		  goto fail;
+		}
+	    }
+	  ndies++;
+	  t = htab_find_with_hash (abbrev, &tag, tag.entry);
+	  if (t == NULL)
+	    {
+	      error (0, 0, "%s: Could not find DWARF abbreviation %d",
+		     dso->filename, tag.entry);
+	      goto fail;
+	    }
+	  ptr = skip_attrs_1 (cu_version, t, ptr);
+	}
+    }
+
+  if (low_mem_die_limit_hit)
+    ret = 2;
+  else
+    ret = 0;
+
+ fail:
+  if (abbrev)
+    htab_delete (abbrev);
+
+  return ret;
+}
+
+/* Read language attribute encoded using FORM from location PTR, return
+   pointer to location after the attribute.  Assign the attribute value
+   to *LANG.  */
+static unsigned char *
+read_lang (unsigned char *ptr, enum dwarf_form form,
+	   enum dwarf_source_language *lang)
+{
+  bool error_p = false;
+  *lang = read_u16 (ptr, form, error_p);
+  if (unlikely (error_p))
+    {
+      *lang = 0;
+      error (0, 0, "Invalid DW_AT_language attribute, ignoring");
+    }
+  return ptr;
+}
+
+/* First phase of the DWARF compression.  Parse .debug_info section
+   (for kind == DEBUG_INFO) or .debug_types section (for kind == DEBUG_TYPES)
+   for each CU in it construct internal representation for the CU
+   and its DIE tree, compute checksums of DIEs and look for duplicates.  */
+static int
+read_debug_info (DSO *dso, int kind, unsigned int *die_count)
+{
+  unsigned char *ptr, *endcu, *endsec;
+  unsigned int value;
+  htab_t abbrev = NULL;
+  unsigned int last_abbrev_offset = 0;
+  unsigned int last_debug_line_off = 0;
+  struct dw_file *cu_files = NULL;
+  unsigned int cu_nfiles = 0;
+  bool note_strp_forms = multifile != NULL && !op_multifile
+			 && !rd_multifile && !low_mem;
+  struct abbrev_tag tag, *t;
+  unsigned int cu_chunk = 0;
+  dw_cu_ref cu_tail = NULL, cu_collapse = NULL;
+  unsigned int cu_kind = rd_multifile ? CU_ALT
+			 : kind == DEBUG_TYPES ? CU_TYPES : CU_NORMAL;
+  void *to_free = NULL;
+  int ret = 1;
+  unsigned int ndies;
+  bool low_mem_phase1 = low_mem && kind == DEBUG_INFO;
+  struct dw_cu cu_buf;
+  struct dw_die die_buf;
+  bool lang_p = odr || uni_lang_p;
+
+  odr_active_p = false;
+  if (odr)
+    odr_phase = 1;
+
+  unsigned int estimated_nr_dies = estimate_nr_dies ();
+  if (kind == DEBUG_INFO
+      && multifile_mode == 0
+      && die_count_method == estimate)
+    {
+      bool do_count = (estimated_nr_dies > max_die_limit
+		       || estimated_nr_dies > low_mem_die_limit);
+      if (tracing)
+	fprintf (stderr, "Using die count estimate %u to decide whether to"
+		 " count DIEs: %s\n", estimated_nr_dies,
+		 do_count ? "yes" : "no");
+      if (do_count)
+	{
+	  int try_ret = try_debug_info (dso);
+	  if (try_ret != 0)
+	    return try_ret;
+	}
+    }
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "read_debug_info %s%s\n",
+	       kind == DEBUG_INFO ? ".debug_info" : ".debug_types",
+	       low_mem && kind == DEBUG_INFO ? " (low-mem)" : "");
+    }
+
+  if (likely (!fi_multifile && kind != DEBUG_TYPES))
+    {
+      dup_htab = htab_try_create (100000, die_hash, die_eq, NULL);
+      if (dup_htab == NULL)
+	dwz_oom ();
+    }
+  if (unlikely (meta_abbrev_htab == NULL
+		&& (op_multifile || rd_multifile || fi_multifile || low_mem)))
+    {
+      meta_abbrev_htab
+	= htab_try_create (500, meta_abbrev_hash, meta_abbrev_eq,
+			   meta_abbrev_del);
+      if (meta_abbrev_htab == NULL)
+	dwz_oom ();
+      to_free = obstack_alloc (&ob2, 1);
+    }
+
+ low_mem_phase2:
+  ndies = 0;
+  ptr = debug_sections[kind].data;
+  endsec = ptr + debug_sections[kind].size;
+  while (ptr < endsec)
+    {
+      unsigned int cu_offset = ptr - debug_sections[kind].data;
+      unsigned int tick = 0, culen;
+      int cu_version;
+      dw_cu_ref cu;
+      dw_die_ref *diep, parent, die;
+      bool present;
+      unsigned int debug_line_off;
+      unsigned int type_offset = 0;
+
+      /* Note header is one bigger with DWARF version 5.  */
+      if (ptr + (kind == DEBUG_TYPES ? 23 : 11) > endsec)
+	{
+	  error (0, 0, "%s: %s CU header too small", dso->filename,
+		 debug_sections[kind].name);
+	  goto fail;
+	}
+
+      endcu = ptr + 4;
+      culen = read_32 (ptr);
+      if (culen >= 0xfffffff0)
+	{
+	  error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+	  goto fail;
+	}
+      endcu += culen;
+
+      if (endcu > endsec)
+	{
+	  error (0, 0, "%s: %s too small", dso->filename,
+		 debug_sections[kind].name);
+	  goto fail;
+	}
+
+      cu_version = read_16 (ptr);
+      if (kind == DEBUG_TYPES && (cu_version < 2 || cu_version > 4))
+	{
+	  error (0, 0, "%s: DWARF version %d in .debug_types unhandled",
+		 dso->filename, cu_version);
+	  goto fail;
+	}
+      else if (cu_version < 2 || cu_version > 5)
+	{
+	  error (0, 0, "%s: DWARF version %d in .debug_info unhandled",
+		 dso->filename, cu_version);
+	  goto fail;
+	}
+
+      if (cu_version == 5)
+	{
+	  value = read_8 (ptr);
+	  if (value != DW_UT_compile && value != DW_UT_partial)
+	    {
+	      error (0, 0, "%s: DWARF CU type %s unhandled", dso->filename,
+		     get_DW_UT_str (value));
+	      goto fail;
+	    }
+	}
+      else
+	{
+	  value = read_32 (ptr);
+	  if (value >= debug_sections[DEBUG_ABBREV].size)
+	    {
+	      if (debug_sections[DEBUG_ABBREV].data == NULL)
+		error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+	      else
+		error (0, 0, "%s: DWARF CU abbrev offset too large",
+		       dso->filename);
+	      goto fail;
+	    }
+	}
+
+      if (ptr_size == 0)
+	{
+	  ptr_size = read_8 (ptr);
+	  if (ptr_size != 4 && ptr_size != 8)
+	    {
+	      error (0, 0, "%s: Invalid DWARF pointer size %d",
+		     dso->filename, ptr_size);
+	      goto fail;
+	    }
+	}
+      else if (read_8 (ptr) != ptr_size)
+	{
+	  error (0, 0, "%s: DWARF pointer size differs between CUs",
+		 dso->filename);
+	  goto fail;
+	}
+
+      if (cu_version == 5)
+	{
+	  /* Above we only checked for the smaller version 4 header size.  */
+	  if (ptr + 4 > endsec)
+	    {
+	      error (0, 0, "%s: %s CU version 5 header too small",
+		     dso->filename, debug_sections[kind].name);
+	      goto fail;
+	    }
+	  value = read_32 (ptr);
+	  if (value >= debug_sections[DEBUG_ABBREV].size)
+	    {
+	      if (debug_sections[DEBUG_ABBREV].data == NULL)
+		error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+	      else
+		error (0, 0, "%s: DWARF CU abbrev offset too large",
+		       dso->filename);
+	      goto fail;
+	    }
+	}
+
+      if (unlikely (op_multifile))
+	{
+	  if (ptr == endcu)
+	    {
+	      dw_cu_ref cuf = cu_tail ? cu_tail->cu_next : first_cu;
+	      /* Inside of optimize_multifile, DIE hashes are computed
+		 only after all the CUs from a particular DSO or
+		 executable have been parsed, as we follow
+		 DW_FORM_ref_addr then.  */
+	      for (cu = cuf; cu; cu = cu->cu_next)
+		if (checksum_die (dso, cu, NULL, cu->cu_die))
+		  goto fail;
+
+	      for (cu = cuf; cu; cu = cu->cu_next)
+		checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+
+	      if (dump_dies_p)
+		for (cu = cuf; cu; cu = cu->cu_next)
+		  dump_dies (0, cu->cu_die);
+
+	      for (cu = cuf; cu; cu = cu->cu_next)
+		if (find_dups (cu->cu_die))
+		  goto fail;
+
+	      for (cu = cuf; cu; cu = cu->cu_next)
+		remove_unneeded (cu, cu->cu_die, 0);
+	      for (cu = cuf; cu; cu = cu->cu_next)
+		remove_unneeded (cu, cu->cu_die, 1);
+	      for (cu = cuf; cu; cu = cu->cu_next)
+		remove_unneeded (cu, cu->cu_die, 2);
+
+	      if (cu_collapse == NULL)
+		cu_collapse = first_cu;
+	      while (cu_collapse->cu_chunk < cu_chunk)
+		{
+		  collapse_children (cu_collapse, cu_collapse->cu_die);
+		  cu_collapse = cu_collapse->cu_next;
+		}
+
+	      cu_tail = last_cu;
+	      cu_chunk++;
+	      continue;
+	    }
+	}
+      else
+	cu_chunk++;
+
+      if (unlikely (meta_abbrev_htab != NULL))
+	{
+	  struct meta_abbrev_entry m, *mp;
+	  void **slot;
+	  m.abbrev_off = value;
+	  slot = htab_find_slot_with_hash (meta_abbrev_htab, &m,
+					   m.abbrev_off, INSERT);
+	  if (slot == NULL)
+	    dwz_oom ();
+	  else if (*slot != NULL)
+	    abbrev = ((struct meta_abbrev_entry *) *slot)->abbrev_htab;
+	  else
+	    {
+	      *slot = (void *) &meta_abbrev_fallback;
+	      abbrev
+		= read_abbrev (dso, debug_sections[DEBUG_ABBREV].data + value);
+	      if (abbrev == NULL)
+		goto fail;
+	      mp = (struct meta_abbrev_entry *)
+		   obstack_alloc (&ob2, sizeof (*mp));
+	      mp->abbrev_off = value;
+	      mp->abbrev_htab = abbrev;
+	      *slot = (void *) mp;
+	    }
+	}
+      else if (abbrev == NULL || value != last_abbrev_offset)
+	{
+	  if (abbrev)
+	    htab_delete (abbrev);
+	  abbrev
+	    = read_abbrev (dso, debug_sections[DEBUG_ABBREV].data + value);
+	  if (abbrev == NULL)
+	    {
+	      error (0, 0, "%s: Couldn't read abbrev at offset 0x%x",
+		     dso->filename, value);
+
+	      goto fail;
+	    }
+	}
+      last_abbrev_offset = value;
+
+      if (unlikely (kind == DEBUG_TYPES))
+	{
+	  ptr += 8;
+	  type_offset = read_32 (ptr);
+	}
+
+      if (unlikely (low_mem_phase1))
+	cu = &cu_buf;
+      else
+	cu = pool_alloc (dw_cu, sizeof (struct dw_cu));
+      memset (cu, '\0', sizeof (*cu));
+      cu->cu_kind = cu_kind;
+      cu->cu_offset = cu_offset;
+      cu->cu_version = cu_version;
+      cu->cu_chunk = cu_chunk;
+      if (unlikely (op_multifile || low_mem))
+	cu->cu_abbrev = abbrev;
+      diep = &cu->cu_die;
+      parent = NULL;
+      if (unlikely (low_mem_phase1))
+	;
+      else if (first_cu == NULL)
+	first_cu = last_cu = cu;
+      else
+	{
+	  last_cu->cu_next = cu;
+	  last_cu = cu;
+	}
+
+      while (ptr < endcu)
+	{
+	  unsigned int i;
+	  unsigned int die_offset = ptr - debug_sections[kind].data;
+
+	  tag.entry = read_uleb128 (ptr);
+	  if (tag.entry == 0)
+	    {
+	      if (unlikely (low_mem_phase1))
+		continue;
+	      if (parent)
+		{
+		  diep = &parent->die_sib;
+		  parent->u.p1.die_exit = tick++;
+		  if (parent->die_root == 0)
+		    parent = parent->die_parent;
+		  else
+		    parent = NULL;
+		}
+	      else
+		diep = NULL;
+	      continue;
+	    }
+	  if (diep == NULL)
+	    {
+	      error (0, 0, "%s: Wrong %s DIE tree", dso->filename,
+		     debug_sections[kind].name);
+	      goto fail;
+	    }
+	  t = htab_find_with_hash (abbrev, &tag, tag.entry);
+	  if (t == NULL)
+	    {
+	      error (0, 0, "%s: Could not find DWARF abbreviation %d",
+		     dso->filename, tag.entry);
+	      goto fail;
+	    }
+	  if (likely (!op_multifile && !rd_multifile && !fi_multifile)
+	      && likely (kind == DEBUG_INFO))
+	    {
+	      if (ndies == max_die_limit)
+		{
+		  error (0, 0, "%s: Too many DIEs, not optimizing",
+			 dso->filename);
+		  goto fail;
+		}
+	      /* If we reach the DIE limit, silently signal the dwz
+		 caller that it should retry with low_mem.  */
+	      if (likely (!low_mem) && ndies == low_mem_die_limit)
+		{
+		  if (tracing)
+		    fprintf (stderr, "Hit low-mem die-limit\n");
+		  ret = 2;
+		  goto fail;
+		}
+	    }
+	  ndies++;
+	  if (unlikely (low_mem_phase1))
+	    die = &die_buf;
+	  else if (parent == NULL
+		   || parent->die_root
+		   || parent->die_named_namespace)
+	    {
+	      die = pool_alloc (dw_die, sizeof (struct dw_die));
+	      memset (die, '\0', sizeof (struct dw_die));
+	      die->die_toplevel = 1;
+	    }
+	  else
+	    {
+	      if (die_nontoplevel_freelist)
+		{
+		  die = die_nontoplevel_freelist;
+		  die_nontoplevel_freelist = die->die_sib;
+		}
+	      else
+		die = pool_alloc (dw_die, offsetof (struct dw_die, die_dup));
+	      memset (die, '\0', offsetof (struct dw_die, die_dup));
+	    }
+	  *diep = die;
+	  die->die_tag = t->tag;
+	  die->die_abbrev = t;
+	  die->die_offset = die_offset;
+	  if (parent)
+	    die->die_parent = parent;
+	  else
+	    {
+	      die->die_root = 1;
+	      die->die_parent = (dw_die_ref) cu;
+	    }
+	  die->u.p1.die_enter = tick;
+	  die->u.p1.die_exit = tick++;
+	  if (likely (!low_mem_phase1))
+	    {
+	      if (t->children)
+		{
+		  diep = &die->die_child;
+		  parent = die;
+		}
+	      else
+		diep = &die->die_sib;
+	    }
+	  for (i = 0; i < t->nattr; ++i)
+	    {
+	      uint32_t form = t->attr[i].form;
+	      size_t len = 0;
+
+	      while (form == DW_FORM_indirect)
+		{
+		  form = read_uleb128 (ptr);
+		  if (ptr > endcu)
+		    {
+		      error (0, 0, "%s: Attributes extend beyond end of CU",
+			     dso->filename);
+		      goto fail;
+		    }
+		}
+
+	      /* Get length of expr/blocks first.  Canonicalize all,
+		 except exprloc, to DW_FORM_block1.  */
+	      switch (form)
+		{
+		case DW_FORM_block1:
+		  len = *ptr++;
+		  break;
+		case DW_FORM_block2:
+		  len = read_16 (ptr);
+		  form = DW_FORM_block1;
+		  break;
+		case DW_FORM_block4:
+		  len = read_32 (ptr);
+		  form = DW_FORM_block1;
+		  break;
+		case DW_FORM_block:
+		  len = read_uleb128 (ptr);
+		  form = DW_FORM_block1;
+		  break;
+		case DW_FORM_exprloc:
+		  len = read_uleb128 (ptr);
+		  break;
+		default:
+		  break;
+		}
+
+	      if (unlikely (low_mem_phase1)
+		  && add_locexpr_dummy_dies (dso, cu, die, ptr, form,
+					     t->attr[i].attr, len))
+		  goto fail;
+
+	      switch (form)
+		{
+		case DW_FORM_ref_addr:
+		  if (unlikely (low_mem_phase1))
+		    {
+		      unsigned int offset
+			= read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+		      add_dummy_die (cu, offset);
+		    }
+		  ptr += cu->cu_version == 2 ? ptr_size : 4;
+		  break;
+		case DW_FORM_addr:
+		  ptr += ptr_size;
+		  break;
+		case DW_FORM_flag_present:
+		  break;
+		case DW_FORM_implicit_const:
+		  if (lang_p
+		      && (die->die_tag == DW_TAG_compile_unit
+			  || die->die_tag == DW_TAG_partial_unit)
+		      && t->attr[i].attr == DW_AT_language)
+		    cu->lang = t->values[i];
+		  break;
+		case DW_FORM_data1:
+		  if (lang_p
+		      && (die->die_tag == DW_TAG_compile_unit
+			  || die->die_tag == DW_TAG_partial_unit)
+		      && t->attr[i].attr == DW_AT_language)
+		    cu->lang = *ptr;
+		  /* FALLTHRU */
+		case DW_FORM_ref1:
+		case DW_FORM_flag:
+		  ++ptr;
+		  break;
+		case DW_FORM_data2:
+		  if (lang_p
+		      && (die->die_tag == DW_TAG_compile_unit
+			  || die->die_tag == DW_TAG_partial_unit)
+		      && t->attr[i].attr == DW_AT_language)
+		    cu->lang = do_read_16 (ptr);
+		  /* FALLTHRU */
+		case DW_FORM_ref2:
+		  ptr += 2;
+		  break;
+		case DW_FORM_data4:
+		  if (lang_p
+		      && (die->die_tag == DW_TAG_compile_unit
+			  || die->die_tag == DW_TAG_partial_unit)
+		      && t->attr[i].attr == DW_AT_language)
+		    read_lang (ptr, form, &cu->lang);
+		  /* FALLTHRU */
+		case DW_FORM_ref4:
+		case DW_FORM_sec_offset:
+		  ptr += 4;
+		  break;
+		case DW_FORM_data8:
+		  if (lang_p
+		      && (die->die_tag == DW_TAG_compile_unit
+			  || die->die_tag == DW_TAG_partial_unit)
+		      && t->attr[i].attr == DW_AT_language)
+		    read_lang (ptr, form, &cu->lang);
+		  /* FALLTHRU */
+		case DW_FORM_ref8:
+		case DW_FORM_ref_sig8:
+		  ptr += 8;
+		  break;
+		case DW_FORM_data16:
+		  ptr += 16;
+		  break;
+		case DW_FORM_sdata:
+		case DW_FORM_udata:
+		  if (lang_p
+		      && (die->die_tag == DW_TAG_compile_unit
+			  || die->die_tag == DW_TAG_partial_unit)
+		      && t->attr[i].attr == DW_AT_language)
+		    {
+		      ptr = read_lang (ptr, form, &cu->lang);
+		      break;
+		    }
+		  /* FALLTHRU */
+		case DW_FORM_ref_udata:
+		  skip_leb128 (ptr);
+		  break;
+		case DW_FORM_strp:
+		  if (t->attr[i].attr == DW_AT_name
+		      && (die->die_tag == DW_TAG_namespace
+			  || die->die_tag == DW_TAG_module)
+		      && !die->die_root
+		      && (die->die_parent->die_root
+			  || die->die_parent->die_named_namespace))
+		    die->die_named_namespace = 1;
+		  if (note_strp_forms)
+		    note_strp_offset (read_32 (ptr));
+		  else
+		    ptr += 4;
+		  break;
+		case DW_FORM_line_strp:
+		  if (t->attr[i].attr == DW_AT_name
+		      && (die->die_tag == DW_TAG_namespace
+			  || die->die_tag == DW_TAG_module)
+		      && !die->die_root
+		      && (die->die_parent->die_root
+			  || die->die_parent->die_named_namespace))
+		    die->die_named_namespace = 1;
+		  /* Don't note strp, different string table.  */
+		  ptr += 4;
+		  break;
+		case DW_FORM_string:
+		  ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+		  if (t->attr[i].attr == DW_AT_name
+		      && (die->die_tag == DW_TAG_namespace
+			  || die->die_tag == DW_TAG_module)
+		      && !die->die_root
+		      && (die->die_parent->die_root
+			  || die->die_parent->die_named_namespace))
+		    die->die_named_namespace = 1;
+		  break;
+		case DW_FORM_indirect:
+		  abort ();
+		/* All expr/blocks lengths already handled above.
+		   Just canonicalize exprloc to block1 too.  */
+		case DW_FORM_exprloc:
+		  form = DW_FORM_block1;
+		  break;
+		case DW_FORM_block1:
+		  break;
+		case DW_FORM_block2:
+		case DW_FORM_block4:
+		case DW_FORM_block:
+		  abort ();
+		default:
+		  error (0, 0, "%s: Unknown DWARF %s at DIE [%x]",
+			 dso->filename, get_DW_FORM_str (form), die_offset);
+		  goto fail;
+		}
+
+	      if (ptr > endcu)
+		{
+		  error (0, 0, "%s: Attributes extend beyond end of CU "
+			 "for DIE [%x]",
+			 dso->filename, die_offset);
+		  goto fail;
+		}
+
+	      if (form == DW_FORM_block1)
+		{
+		  if (len >= (size_t) (endcu - ptr))
+		    {
+		      error (0, 0, "%s: Attributes extend beyond end of CU "
+			     "for DIE [%x]",
+			     dso->filename, die_offset);
+		      goto fail;
+		    }
+
+		  if (t->attr[i].attr > DW_AT_loclists_base
+		      && (t->attr[i].attr < DW_AT_MIPS_fde
+			  || t->attr[i].attr > DW_AT_MIPS_has_inlines)
+		      && (t->attr[i].attr < DW_AT_sf_names
+			  || t->attr[i].attr > DW_AT_body_end)
+		      && (t->attr[i].attr < DW_AT_GNU_call_site_value
+			  || t->attr[i].attr
+			     > DW_AT_GNU_call_site_target_clobbered))
+		    {
+		      error (0, 0, "%s: Unknown DWARF %s with "
+				   "block DW_FORM for DIE [%x]",
+			     dso->filename, get_DW_AT_str (t->attr[i].attr),
+			     die_offset);
+		      goto fail;
+		    }
+
+		  ptr += len;
+		}
+	    }
+	  die->die_size = (ptr - debug_sections[kind].data)
+			  - die_offset;
+	  if (unlikely (low_mem))
+	    {
+	      if (low_mem_phase1)
+		continue;
+	      if (off_htab != NULL && kind == DEBUG_INFO)
+		{
+		  void **slot
+		    = htab_find_slot_with_hash (off_htab, die, off_hash (die),
+						INSERT);
+		  if (slot == NULL)
+		    dwz_oom ();
+		  if (*slot != NULL)
+		    {
+		      dw_die_ref ref = (dw_die_ref) *slot;
+		      assert (ref->die_collapsed_child);
+		      die->die_referenced = 1;
+		      die->die_intercu_referenced = 1;
+		      memset (ref, '\0', offsetof (struct dw_die, die_child));
+		      ref->die_parent = die_collapsed_child_freelist;
+		      die_collapsed_child_freelist = ref;
+		    }
+		  *slot = (void *) die;
+		  continue;
+		}
+	    }
+
+	  off_htab_add_die (cu, die, die_count);
+	}
+
+      if (unlikely (low_mem_phase1))
+	continue;
+
+      if (cu->cu_die == NULL
+	  || (cu->cu_die->die_tag != DW_TAG_compile_unit
+	      && cu->cu_die->die_tag != DW_TAG_partial_unit
+	      && cu->cu_die->die_tag != DW_TAG_type_unit)
+	  || cu->cu_die->die_sib != NULL)
+	{
+	  error (0, 0, "%s: %s section chunk doesn't contain a single"
+			" compile_unit or partial_unit", dso->filename,
+		 debug_sections[kind].name);
+	  goto fail;
+	}
+
+      cu->cu_comp_dir = get_AT_string (cu->cu_die, DW_AT_comp_dir);
+      if (skip_producers_p
+	  && skip_producer (get_AT_string (cu->cu_die, DW_AT_producer)))
+	{
+	  cu->cu_die->die_remove = 1;
+	  continue;
+	}
+      enum dwarf_form form;
+      debug_line_off
+	= get_AT_int (cu->cu_die, DW_AT_stmt_list, &present, &form);
+      if (present)
+	{
+	  if (!(form == DW_FORM_sec_offset || form == DW_FORM_data4))
+	    {
+	      error (0, 0, "%s: DW_AT_stmt_list not DW_FORM_sec_offset or"
+		     " DW_FORM_data4", dso->filename);
+	      goto fail;
+	    }
+
+	  if (cu_files != NULL && last_debug_line_off == debug_line_off)
+	    {
+	      cu->cu_nfiles = cu_nfiles;
+	      cu->cu_files = cu_files;
+	    }
+	  else
+	    {
+	      if (read_debug_line (dso, cu, debug_line_off))
+		goto fail;
+	      cu_nfiles = cu->cu_nfiles;
+	      cu_files = cu->cu_files;
+	      last_debug_line_off = debug_line_off;
+	    }
+	}
+
+      if (likely (!op_multifile && !rd_multifile && !fi_multifile)
+	  && likely (kind == DEBUG_INFO))
+	{
+	  if (checksum_die (dso, cu, NULL, cu->cu_die))
+	    goto fail;
+	  checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+	  if (odr)
+	    {
+	      dw_die_ref die;
+	      FOREACH_LOW_TOPLEVEL_DIE_IN_CU (die, cu)
+		{
+		  if (die->die_ck_state != CK_KNOWN)
+		    continue;
+		  if (die_odr_state (die) != ODR_NONE)
+		    die->u.p1.die_ref_hash = die->u.p1.die_hash;
+		  else
+		    die->die_ref_hash_computed = 0;
+		}
+	      checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+	    }
+
+	  if (dump_dies_p)
+	    dump_dies (0, cu->cu_die);
+
+	  if (find_dups (cu->cu_die))
+	    goto fail;
+	}
+      if (unlikely (kind == DEBUG_TYPES))
+	{
+	  dw_die_ref ref = off_htab_lookup (cu, cu->cu_offset + type_offset);
+	  if (ref == NULL)
+	    {
+	      error (0, 0, "%s: Couldn't find DIE at [%x] "
+		     "referenced by type_offset from cu DIE at [%x]",
+		     dso->filename, cu->cu_offset + type_offset,
+		     cu->cu_die->die_offset);
+	      goto fail;
+	    }
+	  if (unlikely (low_mem))
+	    {
+	      ref->die_referenced = 1;
+	      ref->die_intercu_referenced = 1;
+	    }
+	}
+      if (unlikely (low_mem))
+	{
+	  remove_unneeded (cu, cu->cu_die, 1);
+	  remove_unneeded (cu, cu->cu_die, 2);
+	  collapse_children (cu, cu->cu_die);
+	}
+    }
+
+  if (unlikely (low_mem_phase1))
+    {
+      low_mem_phase1 = false;
+      cu_chunk = 0;
+      goto low_mem_phase2;
+    }
+
+  if (unlikely (low_mem))
+    ;
+  else if (unlikely (meta_abbrev_htab != NULL))
+    {
+      dw_cu_ref cu;
+
+      if (unlikely (op_multifile))
+	for (cu = first_cu; cu; cu = cu->cu_next)
+	  cu->cu_abbrev = NULL;
+      htab_delete (meta_abbrev_htab);
+      meta_abbrev_htab = NULL;
+      obstack_free (&ob2, to_free);
+      abbrev = NULL;
+    }
+  else if (abbrev)
+    htab_delete (abbrev);
+
+  if (unlikely (kind == DEBUG_TYPES))
+    return 0;
+
+  if (unlikely (rd_multifile || fi_multifile))
+    {
+      dw_cu_ref cu;
+
+      /* Inside of read_multifile, DIE hashes are computed
+	 only after all the PUs are parsed, as we follow
+	 DW_FORM_ref_addr then.  */
+      for (cu = first_cu; cu; cu = cu->cu_next)
+	if (checksum_die (dso, cu, NULL, cu->cu_die))
+	  goto fail;
+
+      for (cu = first_cu; cu; cu = cu->cu_next)
+	checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+
+      if (dump_dies_p)
+	for (cu = first_cu; cu; cu = cu->cu_next)
+	  dump_dies (0, cu->cu_die);
+
+      if (rd_multifile)
+	{
+	  for (cu = first_cu; cu; cu = cu->cu_next)
+	    if (find_dups (cu->cu_die))
+	      goto fail;
+	}
+      else
+	for (cu = first_cu; cu; cu = cu->cu_next)
+	  if (find_dups_fi (cu->cu_die))
+	    goto fail;
+
+      return 0;
+    }
+
+  if (tracing)
+    {
+      if (op_multifile)
+	fprintf (stderr, "Die count: %u\n", ndies);
+      else
+	fprintf (stderr, "Die count: %u, %.2f%% of estimate\n", ndies,
+		 (double)ndies / ((double)estimated_nr_dies / 100));
+    }
+  if (tracing)
+    htab_report (off_htab, "off_htab post-parsing");
+  if (stats_p)
+    stats->die_count = ndies;
+  if (die_count)
+    *die_count = ndies;
+  htab_delete (dup_htab);
+  dup_htab = NULL;
+  return 0;
+fail:
+  if (unlikely (meta_abbrev_htab != NULL))
+    {
+      dw_cu_ref cu;
+
+      for (cu = first_cu; cu; cu = cu->cu_next)
+	cu->cu_abbrev = NULL;
+      htab_delete (meta_abbrev_htab);
+      meta_abbrev_htab = NULL;
+      obstack_free (&ob2, to_free);
+    }
+  else if (abbrev)
+    htab_delete (abbrev);
+  if (dup_htab && kind == DEBUG_INFO)
+    {
+      htab_delete (dup_htab);
+      dup_htab = NULL;
+    }
+  return ret;
+}
+
+/* Compare function called from qsort, which should ensure that
+   dup candidate dies with the same set of referrer CUs are
+   adjacent.  */
+static int
+partition_cmp (const void *p, const void *q)
+{
+  dw_die_ref die1 = *(dw_die_ref *) p;
+  dw_die_ref die2 = *(dw_die_ref *) q;
+  dw_die_ref ref1, ref2;
+  dw_cu_ref last_cu1 = NULL, last_cu2 = NULL;
+  ref1 = die1;
+  ref2 = die2;
+  if (odr_active_p && odr_mode != ODR_BASIC)
+    {
+      while (ref1 && die_odr_state (ref1) == ODR_DECL)
+	ref1 = ref1->die_nextdup;
+      if (ref1 == NULL)
+	ref1 = die1;
+      while (ref2 && die_odr_state (ref2) == ODR_DECL)
+	ref2 = ref2->die_nextdup;
+      if (ref2 == NULL)
+	ref2 = die2;
+    }
+  for (;; ref1 = ref1->die_nextdup, ref2 = ref2->die_nextdup)
+    {
+      dw_cu_ref ref1cu = NULL;
+      dw_cu_ref ref2cu = NULL;
+      while (ref1 && (ref1cu = die_cu (ref1)) == last_cu1)
+	ref1 = ref1->die_nextdup;
+      while (ref2 && (ref2cu = die_cu (ref2)) == last_cu2)
+	ref2 = ref2->die_nextdup;
+      if (ref1 == NULL || ref2 == NULL)
+	break;
+      last_cu1 = ref1cu;
+      last_cu2 = ref2cu;
+      if (last_cu1->cu_offset < last_cu2->cu_offset)
+	return -1;
+      else if (last_cu1->cu_offset > last_cu2->cu_offset)
+	return 1;
+    }
+  if (ref1)
+    return -1;
+  if (ref2)
+    return 1;
+  /* The rest is just to keep sort stable.  */
+  if (die1->die_offset < die2->die_offset)
+    return -1;
+  if (die1->die_offset > die2->die_offset)
+    return 1;
+  return 0;
+}
+
+/* Add duplicate chain for DIE to VEC.  */
+static void
+partition_found_dups (dw_die_ref die, struct obstack *vec)
+{
+  assert (die->die_ck_state == CK_KNOWN);
+  obstack_ptr_grow (vec, die);
+  if (unlikely (verify_dups_p))
+    verify_dups (die, true);
+
+  if (stats_p)
+    {
+      uint64_t length = 0;
+      for (; die; die = die->die_nextdup)
+	length++;
+      stats->dup_cnt += length;
+      stats->dup_chain_max_length = MAX (stats->dup_chain_max_length, length);
+      stats->dup_chain_cnt++;
+    }
+}
+
+/* Sort duplication chain for HEAD, assuming the chain was formed by
+   die_eq.  */
+static void
+sort_dups (dw_die_ref head)
+{
+  dw_die_ref prev = NULL, die, next;
+  /* Sort the die_nextdup list by increasing die_cu ()->cu_chunk.
+     When it is originally added, child has the lowest
+     cu_offset, then the DIEs are sorted in the linked list
+     from highest cu_offset down to lowest or second lowest.  */
+  for (die = head->die_nextdup; die; prev = die, die = next)
+    {
+      next = die->die_nextdup;
+      die->die_nextdup = prev;
+    }
+  head->die_nextdup = prev;
+}
+
+/* Merge duplicate chains D and D2, and return the head of the merged
+chain.  */
+static dw_die_ref
+merge_dups (dw_die_ref d, dw_die_ref d2)
+{
+  if (d == NULL)
+    return d2;
+  if (d2 == NULL)
+    return d;
+
+  dw_die_ref tail = NULL;
+  dw_die_ref head = NULL;
+  while (true)
+    {
+      dw_die_ref next;
+      if (d && d2)
+	{
+	  if (d->die_offset < d2->die_offset)
+	    {
+	      next = d;
+	      d = d->die_nextdup;
+	    }
+	  else
+	    {
+	      next = d2;
+	      d2 = d2->die_nextdup;
+	    }
+	}
+      else if (d)
+	{
+	  next = d;
+	  d = d->die_nextdup;
+	}
+      else if (d2)
+	{
+	  next = d2;
+	  d2 = d2->die_nextdup;
+	}
+      else
+	break;
+      if (!head)
+	head = next;
+      if (tail)
+	tail->die_nextdup = next;
+      tail = next;
+    }
+
+  for (d = head; d; d = d->die_nextdup)
+    if (d == head)
+      d->die_dup = NULL;
+    else
+      d->die_dup = head;
+
+  if (unlikely (verify_dups_p))
+    verify_dups (head, true);
+  return head;
+}
+
+static void
+mark_singletons (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die,
+		 struct obstack *vec)
+{
+  struct abbrev_tag *t;
+  unsigned int i;
+  unsigned char *ptr;
+  dw_die_ref child;
+  bool found;
+
+  t = die->die_abbrev;
+
+  found = false;
+  for (i = 0; i < t->nattr; ++i)
+    {
+      struct abbrev_attr *attr = &t->attr[i];
+      if (attr->attr == DW_AT_sibling)
+	continue;
+      switch (attr->form)
+	{
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	case DW_FORM_indirect:
+	  found = true;
+	  break;
+	}
+    }
+  if (!found)
+    goto handle_children;
+
+  if (unlikely (cu->cu_kind == CU_TYPES))
+    ptr = debug_sections[DEBUG_TYPES].data;
+  else
+    ptr = debug_sections[DEBUG_INFO].data;
+  ptr += die->die_offset;
+  skip_leb128 (ptr);
+  for (i = 0; i < t->nattr; ++i)
+    {
+      struct abbrev_attr *attr = &t->attr[i];
+      uint32_t form = attr->form;
+      uint64_t value;
+      dw_die_ref ref, reft;
+
+      while (form == DW_FORM_indirect)
+	form = read_uleb128 (ptr);
+
+      switch (form)
+	{
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	  switch (form)
+	    {
+	    case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+	    case DW_FORM_ref1: value = read_8 (ptr); break;
+	    case DW_FORM_ref2: value = read_16 (ptr); break;
+	    case DW_FORM_ref4: value = read_32 (ptr); break;
+	    case DW_FORM_ref8: value = read_64 (ptr); break;
+	    default: abort ();
+	    }
+	  if (t->attr[i].attr == DW_AT_sibling)
+	    break;
+	  ref = off_htab_lookup (cu, cu->cu_offset + value);
+	  if (!ref->die_collapsed_child
+	      && ref->u.p1.die_enter >= top_die->u.p1.die_enter
+	      && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+	    break;
+	  reft = ref;
+	  while (!reft->die_root
+		 && reft->die_parent->die_tag != DW_TAG_compile_unit
+		 && reft->die_parent->die_tag != DW_TAG_partial_unit
+		 && !reft->die_parent->die_named_namespace)
+	    reft = reft->die_parent;
+	  if (reft->die_dup != NULL || reft->die_nextdup != NULL)
+	    break;
+	  if (reft->die_ref_seen)
+	    break;
+	  reft->die_ref_seen = 1;
+	  partition_found_dups (reft, vec);
+	  mark_singletons (die_cu (reft), reft, reft, vec);
+	  break;
+	default:
+	  ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+	  break;
+	}
+    }
+
+ handle_children:
+  for (child = die->die_child; child; child = child->die_sib)
+    mark_singletons (cu, top_die, child, vec);
+}
+
+/* Split maximal duplicate chain DIE into smaller chains that contain
+   structurally equal defs, and combine the decls with one of those.
+   Return the first chain, and call partition_found_dups for the others.  */
+static dw_die_ref
+split_dups (dw_die_ref die, struct obstack *vec)
+{
+  dw_die_ref res = NULL;
+
+  /* Count the DIEs in the duplicate chain.  */
+  unsigned count = 0;
+  dw_die_ref d;
+  for (d = die; d; d = d->die_nextdup)
+    count++;
+  assert (count >= 2);
+
+  /* Break up the duplicate chain.  */
+  dw_die_ref arr[count];
+  unsigned int i;
+  for (d = die, i = 0; d; d = d->die_nextdup, i++)
+    arr[i] = d;
+  for (i = 0; i < count; i++)
+    {
+      d = arr[i];
+      d->die_nextdup = NULL;
+      d->die_dup = NULL;
+    }
+
+  /* Build decls duplicate chain.  */
+  dw_die_ref tail = NULL;
+  dw_die_ref head = NULL;
+  for (i = 0; i < count; i++)
+    {
+      d = arr[i];
+      if (die_odr_state (d) != ODR_DECL)
+	continue;
+      if (!head)
+	head = d;
+      if (tail)
+	tail->die_nextdup = d;
+      if (d != head)
+	d->die_dup = head;
+      tail = d;
+    }
+  dw_die_ref decls = head;
+
+  /* Build def duplicate chains.  */
+  unsigned int j;
+  dw_die_ref d2;
+  for (i = 0; i < count; i++)
+    {
+      d = arr[i];
+      if (d->die_dup || d->die_nextdup
+	  || die_odr_state (d) == ODR_DECL)
+	continue;
+      tail = d;
+      for (j = i + 1; j < count; j++)
+	{
+	  d2 = arr[j];
+	  if (d2->die_dup || d2->die_nextdup
+	      || die_odr_state (d2) == ODR_DECL)
+	    continue;
+	  die_eq (d, d2);
+	}
+      sort_dups (d);
+    }
+
+  if (odr_mode != ODR_BASIC)
+    {
+      /* Find the first duplicate chain containing defs.  */
+      dw_die_ref def = NULL;
+      for (i = 0; i < count; i++)
+	{
+	  d = arr[i];
+	  if (die_odr_state (d) == ODR_DECL
+	      || d->die_dup != NULL)
+	    continue;
+	  def = d;
+	  break;
+	}
+
+      /* Merge the def chain with the decls.  */
+      merge_dups (def, decls);
+    }
+
+  for (i = 0; i < count; i++)
+    {
+      d = arr[i];
+      if (d->die_dup == NULL)
+	/* If DIE is now either:
+	   - no longer part of a duplicate chain, or
+	   - head of a duplicate chain,
+	   don't remove it.  */
+	d->die_remove = 0;
+    }
+
+  /* Notice the new duplicate chains.  */
+  for (i = 0; i < count; i++)
+    {
+      d = arr[i];
+      if (d->die_dup != NULL)
+	continue;
+      if (res == NULL)
+	res = d;
+      else
+	partition_found_dups (d, vec);
+    }
+  return res;
+}
+
+/* Search for duplicate removal reference DIE candidates
+   in tree rooted by PARENT.  */
+static void
+partition_find_dups (struct obstack *vec, dw_die_ref parent)
+{
+  dw_die_ref child;
+  for (child = parent->die_child; child; child = child->die_sib)
+    {
+      if (child->die_nextdup != NULL
+	  && child->die_dup == NULL
+	  && child->die_offset != -1U)
+	{
+	  dw_die_ref die;
+
+	  if (unlikely (op_multifile))
+	    {
+	      /* If all the dups are from the same DSO or executable,
+		 there is nothing in it to optimize in between different
+		 objects.  */
+	      unsigned int cu_chunk = die_cu (child)->cu_chunk;
+	      for (die = child->die_nextdup; die; die = die->die_nextdup)
+		if (die_cu (die)->cu_chunk != cu_chunk)
+		  break;
+	      if (die == NULL)
+		continue;
+	    }
+	  sort_dups (child);
+	  partition_found_dups (child, vec);
+	}
+      else if (child->die_named_namespace)
+	partition_find_dups (vec, child);
+    }
+}
+
+/* Reorder duplicate chain DIE to make sure it doesn't start with a decl.  */
+static dw_die_ref
+reorder_dups (dw_die_ref die)
+{
+  unsigned decl_count = 0;
+  unsigned def_count = 0;
+  dw_die_ref d;
+
+  if (die_odr_state (die) == ODR_NONE)
+    return die;
+
+  for (d = die; d; d = d->die_nextdup)
+    {
+      if (die_odr_state (d) == ODR_DECL)
+	decl_count++;
+      else
+	def_count++;
+    }
+  if (def_count == 0 || decl_count == 0)
+    return die;
+
+  if (die_odr_state (die) != ODR_DECL)
+    return die;
+
+  dw_die_ref def = NULL;
+  dw_die_ref prev = NULL;
+  for (d = die; d; prev = d, d = d->die_nextdup)
+    {
+      if (die_odr_state (d) == ODR_DECL)
+	continue;
+      def = d;
+      break;
+    }
+
+  assert (!die->die_remove);
+  assert (def->die_remove);
+  def->die_remove = 0;
+  die->die_remove = 1;
+  def->die_ref_seen = die->die_ref_seen;
+  dw_die_ref next = def->die_nextdup;
+  if (prev)
+    prev->die_nextdup = next;
+  def->die_nextdup = die;
+  for (d = def; d; prev = d, d = d->die_nextdup)
+    {
+      if (d == def)
+	d->die_dup = NULL;
+      else
+	d->die_dup = def;
+    }
+
+  if (unlikely (verify_dups_p))
+    verify_dups (def, false);
+  return def;
+}
+
+/* Copy DIE tree of DIE, as children of new DIE PARENT.  */
+static dw_die_ref
+copy_die_tree (dw_die_ref parent, dw_die_ref die)
+{
+  dw_die_ref child, new_child, *diep;
+  dw_die_ref new_die;
+  if (die->die_toplevel)
+    {
+      new_die = pool_alloc (dw_die, sizeof (struct dw_die));
+      memset (new_die, '\0', sizeof (*new_die));
+      new_die->die_toplevel = 1;
+      die->die_dup = new_die;
+      new_die->die_nextdup = die;
+      if (!die->die_op_type_referenced)
+	die->die_remove = 1;
+    }
+  else
+    {
+      new_die = pool_alloc (dw_die, offsetof (struct dw_die, die_dup));
+      memset (new_die, '\0', offsetof (struct dw_die, die_dup));
+    }
+  new_die->die_parent = parent;
+  new_die->die_tag = die->die_tag;
+  new_die->die_offset = -1U;
+  new_die->die_size = die->die_size;
+  diep = &new_die->die_child;
+  for (child = die->die_child; child; child = child->die_sib)
+    {
+      new_child = copy_die_tree (new_die, child);
+      *diep = new_child;
+      diep = &new_child->die_sib;
+    }
+  return new_die;
+}
+
+/* If all DIEs in the duplication chain DIE are in CUs with the same
+   language, return that language.  Otherwise, return 0.  */
+static enum dwarf_source_language
+partition_lang (dw_die_ref die)
+{
+  enum dwarf_source_language lang;
+  dw_die_ref d;
+
+  if (die == NULL)
+    return 0;
+
+  lang = die_cu (die)->lang;
+  switch (lang)
+    {
+    case DW_LANG_C_plus_plus:
+    case DW_LANG_C_plus_plus_03:
+    case DW_LANG_C_plus_plus_11:
+    case DW_LANG_C_plus_plus_14:
+      break;
+    default:
+      return 0;
+    }
+
+  for (d = die->die_nextdup; d; d = d->die_nextdup)
+    if (die_cu (d)->lang != lang)
+      return 0;
+
+  return lang;
+}
+
+/* Return how many bytes we need to encode VAL.  */
+static unsigned int
+nr_bytes_for (uint64_t val)
+{
+  unsigned int n;
+
+  if (val == 0)
+    return 1;
+
+  for (n = 0; val > 0; n++)
+    val = val >> 8;
+
+  return n;
+}
+
+/* Return true if duplicate chains REF1 and REF2 have the same set of
+   referrer CUs.  If so, return the number of unique referrer CUs
+   in *CNT.  */
+static inline unsigned int FORCE_INLINE
+same_ref_cus_p (dw_die_ref ref1, dw_die_ref ref2, size_t *cnt)
+{
+  dw_cu_ref last_cu1 = NULL, last_cu2 = NULL;
+
+  *cnt = 0;
+
+  if (odr_active_p && odr_mode != ODR_BASIC)
+    {
+      dw_die_ref orig_ref1 = ref1, orig_ref2 = ref2;
+      while (ref1 && die_odr_state (ref1) == ODR_DECL)
+	ref1 = ref1->die_nextdup;
+      if (ref1 == NULL)
+	ref1 = orig_ref1;
+      while (ref2 && die_odr_state (ref2) == ODR_DECL)
+	ref2 = ref2->die_nextdup;
+      if (ref2 == NULL)
+	ref2 = orig_ref2;
+    }
+  for (;; ref1 = ref1->die_nextdup, ref2 = ref2->die_nextdup)
+    {
+      dw_cu_ref ref1cu = NULL;
+      dw_cu_ref ref2cu = NULL;
+
+      while (ref1 && (ref1cu = die_cu (ref1)) == last_cu1)
+	ref1 = ref1->die_nextdup;
+      while (ref2 && (ref2cu = die_cu (ref2)) == last_cu2)
+	ref2 = ref2->die_nextdup;
+      if (ref1 == NULL || ref2 == NULL)
+	break;
+
+      last_cu1 = ref1cu;
+      last_cu2 = ref2cu;
+
+      if (last_cu1 != last_cu2)
+	break;
+      else
+	(*cnt)++;
+    }
+
+  if (ref1 || ref2)
+    return false;
+
+  return true;
+}
+
+/* Return the number of unique referrer CUs in duplicate chain REF.  */
+static inline size_t FORCE_INLINE
+cnt_ref_cus (dw_die_ref ref)
+{
+  dw_cu_ref last_cu1 = NULL;
+  size_t cnt = 0;
+
+  for (;; ref = ref->die_nextdup)
+    {
+      dw_cu_ref refcu = NULL;
+      while (ref && (refcu = die_cu (ref)) == last_cu1)
+	ref = ref->die_nextdup;
+      if (ref == NULL)
+	break;
+      last_cu1 = refcu;
+      cnt++;
+    }
+
+  return cnt;
+}
+
+/* Helper function of partition_dups_1.  Decide what DIEs matching in
+   multiple CUs might be worthwhile to be moved into partial units,
+   construct those partial units.  */
+static bool
+partition_dups_1 (dw_die_ref *arr, size_t nr_partitions, size_t *partitions,
+		  dw_cu_ref *first_partial_cu,
+		  dw_cu_ref *last_partial_cu,
+		  bool second_phase)
+{
+  size_t i, j, cnt;
+  bool ret = false;
+  size_t idx = 0;
+  for (idx = 0; idx < nr_partitions * 2; idx += 2)
+    {
+      i = partitions[idx];
+      cnt = partitions[idx + 1];
+      j = partitions[idx + 2];
+
+      if (arr[i]->die_dup != NULL)
+	continue;
+
+      dw_die_ref ref;
+      size_t size = 0, k, orig_size, new_size, namespaces = 0;
+      unsigned int force = 0;
+      enum dwarf_source_language part_lang
+	= gen_cu_p ? partition_lang (arr[i]) : 0;
+      for (k = i; k < j; k++)
+	{
+	  if (second_phase && arr[k]->die_ref_seen)
+	    force++;
+	  size += calc_sizes (arr[k]);
+	  for (ref = arr[k]->die_parent;
+	       ref->die_named_namespace && ref->die_dup == NULL;
+	       ref = ref->die_parent)
+	    {
+	      ref->die_dup = arr[k];
+	      namespaces++;
+	    }
+	}
+      /* If during second_phase there are some DIEs we want to force
+	 into a partial unit because they are referenced from something
+	 already forced into a partial unit, but also some DIEs with
+	 the same set of referrers, try to see if we can put also those
+	 into the partial unit.  They can be put there only if they
+	 don't refer to DIEs that won't be put into partial units.  */
+      if (unlikely (partition_dups_opt)
+	  && second_phase && force && force < j - i)
+	{
+	  /* First optimistically assume all such DIEs can be put there,
+	     thus mark all such DIEs as going to be included, so that
+	     even if one of those DIEs references another one from those
+	     DIEs it can be included.  */
+	  for (k = i; k < j; k++)
+	    {
+	      assert (arr[k]->die_ref_seen < 2);
+	      if (arr[k]->die_ref_seen == 0)
+		arr[k]->die_ref_seen = 2;
+	    }
+	  for (k = i; k < j; k++)
+	    if (arr[k]->die_ref_seen == 2
+		&& !mark_refs (die_cu (arr[k]), arr[k], arr[k],
+			       (MARK_REFS_FOLLOW_DUPS | MARK_REFS_RETURN_VAL)))
+	      break;
+	  /* If that is not possible and some DIEs couldn't be included,
+	     fallback to assume other DIEs won't be included.  */
+	  if (k < j)
+	    {
+	      for (k = i; k < j; k++)
+		if (arr[k]->die_ref_seen == 2)
+		  arr[k]->die_ref_seen = 0;
+	      for (k = i; k < j; k++)
+		if (arr[k]->die_ref_seen == 0)
+		  {
+		    arr[k]->die_ref_seen = 2;
+		    if (!mark_refs (die_cu (arr[k]), arr[k], arr[k],
+				    (MARK_REFS_FOLLOW_DUPS
+				     | MARK_REFS_RETURN_VAL)))
+		      arr[k]->die_ref_seen = 0;
+		  }
+	    }
+	}
+      if (namespaces)
+	{
+	  for (k = i; k < j; k++)
+	    for (ref = arr[k]->die_parent; ref->die_named_namespace;
+		 ref = ref->die_parent)
+	      ref->die_dup = NULL;
+	}
+      orig_size = size * cnt;
+      /* Estimated size of CU header and DW_TAG_partial_unit
+	 with DW_AT_stmt_list and DW_AT_comp_dir attributes
+	 21 (also child end byte).  With DW_AT_language c++, 22.  */
+      size_t pu_size
+	= (/* CU Header: unit length (initial length).
+	      32-bit DWARF: 4 bytes, 64-bit DWARF: 12 bytes.  */
+	   4
+	   /* CU Header: version (uhalf).
+	      2 bytes.  */
+	   + 2
+	   /* CU Header: debug_abbrev_offset (section offset).
+	      32-bit DWARF: 4 bytes, 64-bit DWARF: 8 bytes.  */
+	   + 4
+	   /* CU Header: address_size (ubyte).
+	      1 byte.  */
+	   + 1
+	   /* DWARF5 CU header: unit_type (ubyte).  */
+	   + (die_cu (arr[i])->cu_version >= 5 ? 1 : 0)
+	   /* CU Root DIE: abbreviation code (unsigned LEB128).
+	      1 or more bytes.  Optimistically assume 1.  */
+	   + 1
+	   /* CU Root DIE: DW_AT_stmt_list (lineptr).
+	      32-bit DWARF: 4 bytes, 64-bit DWARF: 8 bytes.  */
+	   + 4
+	   /* CU Root DIE: DW_AT_comp_dir (string).
+	      DW_FORM_strp: 32-bit DWARF: 4 bytes, 64-bit DWARF: 8 bytes.
+	      DW_FORM_string: 1 or more bytes.
+	      Assume 4 bytes.  */
+	   + 4
+	  /* CU Root DIE: DW_AT_language (constant).
+	     1 or 2 bytes.  */
+	   + ((uni_lang_p || part_lang)
+	      ? nr_bytes_for (die_cu (arr[i])->lang)
+	      : 0)
+	   /* CU root DIE children terminator: abbreviation code 0
+					       (unsigned LEB128).
+	      1 byte.  */
+	   + 1);
+      /* DW_TAG_imported_unit with DW_AT_import attribute
+	 (5 or 9 bytes (the latter for DWARF2 and ptr_size 8)).  */
+      size_t import_size
+	= (die_cu (arr[i])->cu_version == 2 ? 1 + ptr_size : 5);
+      /* For DW_TAG_namespace or DW_TAG_module needed as
+	 parents of the DIEs conservatively assume 10 bytes
+	 for the abbrev index, DW_AT_name attribute and
+	 DW_AT_sibling attribute and child end.  */
+      size_t namespace_size = 10;
+      new_size = (/* Size of DIEs.  */
+		  size
+		  /* Size of PU.  */
+		  + pu_size
+		  /* Size of imports.  */
+		  + (part_lang != 0 ? 0 : import_size * cnt)
+		  /* Size of namespace DIEs.  */
+		  + namespace_size * namespaces);
+      if (!second_phase)
+	force = ((deduplication_mode == dm_inter_cu)
+		 && (ignore_size || orig_size > new_size));
+      if (force)
+	{
+	  dw_die_ref die, *diep;
+	  dw_cu_ref refcu = die_cu (arr[i]);
+	  dw_cu_ref partial_cu = pool_alloc (dw_cu, sizeof (struct dw_cu));
+	  memset (partial_cu, '\0', sizeof (*partial_cu));
+	  if (stats_p)
+	    {
+	      if (!second_phase)
+		stats->pu_ph1_cnt++;
+	      else
+		stats->pu_ph2_cnt++;
+	    }
+	  partial_cu->cu_kind = CU_PU;
+	  partial_cu->cu_offset = *last_partial_cu == NULL
+				  ? 0 : (*last_partial_cu)->cu_offset + 1;
+	  if (dump_pus_p)
+	    fprintf (stderr, "Partial unit (%s) @ 0x%x:\n",
+		     second_phase ? "phase two" : "phase one",
+		     partial_cu->cu_offset);
+	  partial_cu->cu_version = refcu->cu_version;
+	  if (uni_lang_p)
+	    partial_cu->lang = refcu->lang;
+	  if (*first_partial_cu == NULL)
+	    *first_partial_cu = *last_partial_cu = partial_cu;
+	  else
+	    {
+	      (*last_partial_cu)->cu_next = partial_cu;
+	      *last_partial_cu = partial_cu;
+	    }
+	  die = pool_alloc (dw_die, sizeof (struct dw_die));
+	  memset (die, '\0', sizeof (*die));
+	  die->die_toplevel = 1;
+	  partial_cu->cu_die = die;
+	  die->die_tag = DW_TAG_partial_unit;
+	  die->die_offset = -1U;
+	  die->die_root = 1;
+	  die->die_parent = (dw_die_ref) partial_cu;
+	  die->die_nextdup = refcu->cu_die;
+	  die->die_size = 9;
+	  diep = &die->die_child;
+	  for (k = i; k < j; k++)
+	    {
+	      dw_die_ref child;
+	      if (second_phase && !arr[k]->die_ref_seen)
+		continue;
+	      if (dump_pus_p)
+		dump_die (arr[k]);
+	      child = copy_die_tree (die, arr[k]);
+	      if (stats_p)
+		stats->pu_toplevel_die_cnt++;
+	      for (ref = arr[k]->die_nextdup; ref; ref = ref->die_nextdup)
+		ref->die_dup = child;
+	      if (unlikely (verify_dups_p))
+		verify_dups (child, odr_mode == ODR_BASIC);
+	      if (part_lang != 0)
+		{
+		  die->die_tag = DW_TAG_compile_unit;
+		  partial_cu->lang = part_lang;
+		}
+	      if (namespaces)
+		{
+		  for (ref = arr[k]->die_parent;
+		       ref->die_named_namespace && ref->die_dup == NULL;
+		       ref = ref->die_parent)
+		    {
+		      dw_die_ref namespc
+			= pool_alloc (dw_die, sizeof (struct dw_die));
+		      memset (namespc, '\0', sizeof (struct dw_die));
+		      namespc->die_toplevel = 1;
+		      namespc->die_tag = ref->die_tag;
+		      namespc->die_offset = -1U;
+		      namespc->die_nextdup = ref;
+		      namespc->die_child = child;
+		      namespc->die_parent = die;
+		      namespc->die_size = 9;
+		      namespc->die_named_namespace = 1;
+		      child->die_parent = namespc;
+		      ref->die_dup = namespc;
+		      child = namespc;
+		    }
+		  if (ref->die_dup != NULL)
+		    {
+		      dw_die_ref *diep2;
+		      for (diep2 = &ref->die_dup->die_child->die_sib;
+			   *diep2; diep2 = &(*diep2)->die_sib)
+			;
+		      *diep2 = child;
+		      child->die_parent = ref->die_dup;
+		      continue;
+		    }
+		}
+	      *diep = child;
+	      diep = &child->die_sib;
+	    }
+	  if (namespaces)
+	    {
+	      for (k = i; k < j; k++)
+		{
+		  if (second_phase && !arr[k]->die_ref_seen)
+		    continue;
+		  for (ref = arr[k]->die_parent;
+		       ref->die_named_namespace; ref = ref->die_parent)
+		    ref->die_dup = NULL;
+		}
+	    }
+	}
+      else if (!second_phase)
+	ret = true;
+      if (second_phase)
+	{
+	  dw_die_ref next;
+	  for (k = i; k < j; k++)
+	    {
+	      if (arr[k]->die_dup != NULL)
+		continue;
+	      for (ref = arr[k]; ref; ref = next)
+		{
+		  dw_cu_ref refcu = die_cu (ref);
+		  next = ref->die_nextdup;
+		  ref->die_dup = NULL;
+		  ref->die_nextdup = NULL;
+		  ref->die_remove = 0;
+		  /* If there are dups within a single CU
+		     (arguably a bug in the DWARF producer),
+		     keep them linked together, but don't link
+		     DIEs across different CUs.  */
+		  while (deduplication_mode != dm_none
+			 && next && refcu == die_cu (next))
+		    {
+		      dw_die_ref cur = next;
+		      next = cur->die_nextdup;
+		      cur->die_dup = ref;
+		      cur->die_nextdup = ref->die_nextdup;
+		      ref->die_nextdup = cur;
+		    }
+		}
+	    }
+	}
+    }
+  return ret;
+}
+
+/* Partition the duplicate chains in array ARR with size VEC_SIZE, and store
+   the partitions on obstack ob2, with for each partition two entries:
+   the start and the number of unique reffer CUs.  */
+static void
+calculate_partitions (dw_die_ref *arr, size_t vec_size)
+{
+  size_t i, j;
+  for (i = 0; i < vec_size; i = j)
+    {
+      size_t cnt = 0;
+      for (j = i + 1; j < vec_size; j++)
+	{
+	  size_t this_cnt;
+	  if (!same_ref_cus_p (arr[i], arr[j], &this_cnt))
+	    break;
+	  cnt = this_cnt;
+	}
+      if (cnt == 0)
+	cnt = cnt_ref_cus (arr[i]);
+      obstack_grow (&ob2, &i, sizeof (size_t));
+      obstack_grow (&ob2, &cnt, sizeof (size_t));
+    }
+
+  /* Add element to mark end of partition list.  This allows us to do
+     'j = partitions[idx + 2]' for all partitions.  */
+  obstack_grow (&ob2, &j, sizeof (size_t));
+  size_t zero = 0;
+  obstack_grow (&ob2, &zero, sizeof (size_t));
+}
+
+static inline void FORCE_INLINE
+reset_die_ref_seen (void)
+{
+  dw_die_ref die;
+  dw_cu_ref cu;
+  FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+    die->die_ref_seen = 0;
+}
+
+/* If the duplicate chain DIE consists of a singleton ODR_DEF die merged with
+   the ODR_DECL chain, return the singleton ODR_DEF die.  Otherwise, return
+   NULL.  */
+static inline dw_die_ref FORCE_INLINE
+merged_singleton (dw_die_ref die)
+{
+  dw_die_ref res = NULL;
+  dw_die_ref d;
+  size_t decl_cnt = 0;
+
+  for (d = die; d; d = d->die_nextdup)
+    switch (die_odr_state (d))
+      {
+      case ODR_DEF:
+	if (res)
+	  {
+	    if (die_cu (res) == die_cu (d))
+	      continue;
+	    else
+	      return NULL;
+	  }
+	else
+	  res = d;
+	break;
+      case ODR_DECL:
+	decl_cnt++;
+	break;
+      default:
+	return NULL;
+      }
+
+  if (decl_cnt == 0)
+    return NULL;
+
+  return res;
+}
+
+/* Decide what DIEs matching in multiple CUs might be worthwhile
+   to be moved into partial units, construct those partial units.  */
+static int
+partition_dups (void)
+{
+  dw_cu_ref cu, first_partial_cu = NULL, last_partial_cu = NULL;
+  size_t vec_size, i;
+  unsigned char *to_free;
+  dw_die_ref *arr;
+
+  if (unlikely (fi_multifile))
+    return 0;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "partition_dups\n");
+    }
+
+  to_free = obstack_alloc (&ob2, 1);
+
+  if (odr_active_p)
+    odr_phase = 2;
+
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    partition_find_dups (&ob2, cu->cu_die);
+  vec_size = obstack_object_size (&ob2) / sizeof (void *);
+
+  if (odr_active_p)
+    {
+      arr = (dw_die_ref *) obstack_base (&ob2);
+      if (progress_p)
+	{
+	  report_progress ();
+	  fprintf (stderr, "partition_dups split_dups\n");
+	}
+      for (i = 0; i < vec_size; i++)
+	{
+	  dw_die_ref die = arr[i];
+	  if (die_odr_state (die) == ODR_NONE)
+	    continue;
+	  die = split_dups (die, &ob2);
+	  assert (die != NULL);
+	  if (unlikely (verify_dups_p))
+	    verify_dups (die, true);
+	  arr = (dw_die_ref *) obstack_base (&ob2);
+	  arr[i] = die;
+	}
+
+      vec_size = obstack_object_size (&ob2) / sizeof (void *);
+
+      reset_die_ref_seen ();
+      for (i = 0; i < vec_size; i++)
+	{
+	  dw_die_ref die = arr[i];
+	  if (die->die_dup == NULL
+	      && die->die_nextdup == NULL)
+	    die->die_ref_seen = 1;
+	}
+      for (i = 0; i < vec_size; i++)
+	{
+	  dw_die_ref die = arr[i];
+	  if (die->die_dup == NULL
+	      && die->die_nextdup == NULL)
+	    mark_singletons (die_cu (die), die, die, &ob2);
+	  else if (odr_mode != ODR_BASIC
+		   && die_odr_state (die) != ODR_NONE)
+	    {
+	      dw_die_ref s = merged_singleton (die);
+	      if (s)
+		mark_singletons (die_cu (s), s, s, &ob2);
+	    }
+	  else if (cnt_ref_cus (die) == 1)
+	    mark_singletons (die_cu (die), die, die, &ob2);
+
+	  arr = (dw_die_ref *) obstack_base (&ob2);
+	}
+
+      vec_size = obstack_object_size (&ob2) / sizeof (void *);
+    }
+
+  if (odr_active_p)
+    odr_phase = 3;
+
+  if (stats_p)
+    print_dups_stats ();
+
+  if (vec_size != 0)
+    {
+      arr = (dw_die_ref *) obstack_finish (&ob2);
+      if (odr_active_p)
+	for (i = 0; i < vec_size; ++i)
+	  {
+	    assert (arr[i] != NULL);
+	    if (unlikely (verify_dups_p))
+	      verify_dups (arr[i], true);
+	  }
+      if (dump_dups_p)
+	{
+	  for (i = 0; i < vec_size; ++i)
+	    {
+	      fprintf (stderr, "duplicate chain:\n");
+	      dump_dups (arr[i]);
+	    }
+	}
+      if (unlikely (progress_p))
+	{
+	  report_progress ();
+	  fprintf (stderr, "partition_dups qsort\n");
+	}
+      qsort (arr, vec_size, sizeof (dw_die_ref), partition_cmp);
+      if (unlikely (progress_p))
+	{
+	  report_progress ();
+	  fprintf (stderr, "partition_dups after qsort\n");
+	}
+
+      size_t *partitions = (size_t *) obstack_base (&ob2);
+      calculate_partitions (arr, vec_size);
+      size_t nr_partitions
+	= (obstack_object_size (&ob2) / sizeof (size_t)) / 2 - 1;
+      partitions = (size_t *) obstack_finish (&ob2);
+      if (stats_p)
+	stats->part_cnt += nr_partitions;
+
+      if (odr_active_p && odr_mode != ODR_BASIC)
+	for (i = 0; i < vec_size; ++i)
+	  arr[i] = reorder_dups (arr[i]);
+      if (partition_dups_1 (arr, nr_partitions, partitions, &first_partial_cu,
+			    &last_partial_cu, false))
+	{
+	  for (i = 0; i < vec_size; i++)
+	    arr[i]->die_ref_seen = arr[i]->die_dup != NULL;
+	  for (i = 0; i < vec_size; i++)
+	    if (arr[i]->die_dup != NULL)
+	      mark_refs (die_cu (arr[i]), arr[i], arr[i],
+			 MARK_REFS_FOLLOW_DUPS);
+	  partition_dups_1 (arr, nr_partitions, partitions, &first_partial_cu,
+			    &last_partial_cu, true);
+	  for (i = 0; i < vec_size; i++)
+	    arr[i]->die_ref_seen = 0;
+	}
+    }
+  if (first_partial_cu)
+    {
+      last_partial_cu->cu_next = first_cu;
+      first_cu = first_partial_cu;
+    }
+  obstack_free (&ob2, to_free);
+
+  if (stats_p)
+    print_part_stats ();
+
+  return 0;
+}
+
+/* The create_import_tree function below and all its helper
+   data structures and functions attempt to optimize the size of
+   DW_TAG_imported_unit DIEs, from the initial assumption that
+   each CU that needs to include some newly created DW_TAG_partial_unit
+   will contain DW_TAG_imported_unit for each such partial unit (PU)
+   (so basically a bipartite graph with CUs and PUs as nodes
+   and DW_TAG_imported_unit DIEs as edges) into a tree, where some
+   of the partial units may also include DW_TAG_imported_unit
+   DIEs, or when beneficial new PUs are created to hold some
+   DW_TAG_imported_unit DIEs.  */
+
+struct import_edge;
+
+/* Structure describing details about a CU or PU (i.e. a node
+   in the graph).  */
+struct import_cu
+{
+  /* Corresponding CU.  CU->u1.cu_icu points back to this
+     structure while in create_import_tree.  */
+  dw_cu_ref cu;
+  /* Linked list of incoming resp. outgoing edges.  */
+  struct import_edge *incoming, *outgoing;
+  /* The tail of the linked list of incoming edges.  */
+  struct import_edge *incoming_tail;
+  /* Next import_cu (used to chain PUs together).  */
+  struct import_cu *next;
+  /* Number of incoming resp. outgoing edges.  */
+  unsigned int incoming_count, outgoing_count;
+  /* Index.  Lowest indexes are assigned to partition_dups
+     created PUs (sorted by decreasing number of incoming
+     edges at the start), then referencing CUs
+     (similarly, sorted by decreasing number of outgoing
+     edges at the start), then optionally any PUs
+     created by create_import_tree.  */
+  unsigned int idx;
+};
+
+/* An edge in a linked list.  */
+struct import_edge
+{
+  struct import_cu *icu;
+  struct import_edge *next;
+};
+
+/* Called through qsort to sort an array of edges by decreasing
+   incoming resp. outgoing_count (this is called when the graph
+   is bipartite, so CUs only have non-zero outgoing_count
+   and PUs only have non-zero incoming_count).  */
+static int
+import_edge_cmp (const void *p, const void *q)
+{
+  struct import_edge *e1 = (struct import_edge *) p;
+  struct import_edge *e2 = (struct import_edge *) q;
+  if (e1->icu->incoming_count > e2->icu->incoming_count)
+    return -1;
+  if (e1->icu->incoming_count < e2->icu->incoming_count)
+    return 1;
+  if (e1->icu->outgoing_count > e2->icu->outgoing_count)
+    return -1;
+  if (e1->icu->outgoing_count < e2->icu->outgoing_count)
+    return 1;
+  /* The rest is just to keep qsort stable.  */
+  if (e1->icu->cu->cu_offset < e2->icu->cu->cu_offset)
+    return -1;
+  if (e1->icu->cu->cu_offset > e2->icu->cu->cu_offset)
+    return 1;
+  return 0;
+}
+
+/* Called through qsort to sort an array of CUs/PUs by decreasing
+   incoming resp. outgoing_count (this is called when the graph
+   is bipartite, so CUs only have non-zero outgoing_count
+   and PUs only have non-zero incoming_count).  */
+static int
+import_cu_cmp (const void *p, const void *q)
+{
+  struct import_cu *c1 = *(struct import_cu **) p;
+  struct import_cu *c2 = *(struct import_cu **) q;
+  if (c1->incoming_count > c2->incoming_count)
+    return -1;
+  if (c1->incoming_count < c2->incoming_count)
+    return 1;
+  if (c1->outgoing_count > c2->outgoing_count)
+    return -1;
+  if (c1->outgoing_count < c2->outgoing_count)
+    return 1;
+  /* The rest is just to keep qsort stable.  */
+  if (c1->cu->cu_offset < c2->cu->cu_offset)
+    return -1;
+  if (c1->cu->cu_offset > c2->cu->cu_offset)
+    return 1;
+  return 0;
+}
+
+/* Freelist for removed edges.  */
+static struct import_edge *edge_freelist;
+
+/* Prepare edge E to add to edge_freelist.  */
+static inline void FORCE_INLINE
+prepare_free_edge (struct import_edge *e UNUSED)
+{
+#if DEVEL
+  e->icu = (void *)(uintptr_t)-1;
+#endif
+}
+
+/* Add edge E to edge_freelist.  */
+static inline void FORCE_INLINE
+free_edge (struct import_edge *e)
+{
+  prepare_free_edge (e);
+  e->next = edge_freelist;
+  edge_freelist = e;
+}
+
+/* Add edge list starting at HEAD and ending at TAIL to edge_freelist.
+   Assume that prepare_free_edge has been called on all elements.  */
+static inline void FORCE_INLINE
+free_edges (struct import_edge *head, struct import_edge *tail)
+{
+#if DEVEL
+  if (verify_edge_freelist)
+    {
+      struct import_edge *e;
+      for (e = head; e; e = e->next)
+	{
+	  assert (e->icu == (void *)(uintptr_t)-1);
+	  if (e == tail)
+	    break;
+	}
+      assert (e != NULL);
+    }
+#endif
+  tail->next = edge_freelist;
+  edge_freelist = head;
+}
+
+/* Detach an edge from edge_freelist, and return it.  */
+static inline struct import_edge * FORCE_INLINE
+edge_from_freelist (void)
+{
+#if DEVEL
+  assert (edge_freelist);
+#endif
+  struct import_edge *e = edge_freelist;
+  edge_freelist = edge_freelist->next;
+#if DEVEL
+  e->next = (void *)(uintptr_t)-1;
+#endif
+  return e;
+}
+
+/* Return edge_freelist, and set it to NULL.  */
+static inline struct import_edge * FORCE_INLINE
+first_edge_from_freelist (void)
+{
+#if DEVEL
+  assert (edge_freelist);
+#endif
+  struct import_edge *e = edge_freelist;
+#if DEVEL
+  edge_freelist = NULL;
+#endif
+  return e;
+}
+
+/* Set edge_freelist to TAIL->next and return HEAD.  Assume HEAD was returned
+   by first_edge_from_freelist, and TAIL is reachable from HEAD.  */
+static inline struct import_edge * FORCE_INLINE
+last_edge_from_freelist (struct import_edge *head, struct import_edge *tail)
+{
+#if DEVEL
+  assert (!edge_freelist);
+  if (verify_edge_freelist)
+    {
+      struct import_edge *e;
+      for (e = head; e; e = e->next)
+	{
+	  if (e == tail)
+	    break;
+	}
+      assert (e != NULL);
+    }
+#endif
+  edge_freelist = tail->next;
+  tail->next = NULL;
+  return head;
+}
+
+/* Remove edges in linked list EP that refer to CUS, which
+   is an array of CUCOUNT CUs/PUs.  If ADD is true, additionally
+   add a new edge at the end of the linked list and return it.  */
+static struct import_edge *
+remove_import_edges (struct import_edge **ep, struct import_edge **ep_tail,
+		     struct import_cu **cus, unsigned int cucount, bool add)
+{
+  unsigned int i = 0;
+  struct import_edge *e, *efirst = NULL, *prev = NULL;
+  while (*ep)
+    if (i < cucount && (*ep)->icu == cus[i])
+      {
+	e = *ep;
+	*ep = e->next;
+	if (efirst == NULL)
+	  efirst = e;
+	else
+	  free_edge (e);
+	i++;
+	if (ep_tail && *ep_tail == e)
+	  *ep_tail = prev;
+	if (i == cucount && !add)
+	  return NULL;
+      }
+    else
+      {
+	if (ep_tail)
+	  prev = *ep;
+	ep = &(*ep)->next;
+      }
+  assert (i == cucount);
+  *ep = efirst;
+  efirst->next = NULL;
+  if (ep_tail)
+    *ep_tail = efirst;
+  return efirst;
+}
+
+static void
+dump_edges_1 (struct import_cu *ipu)
+{
+  fprintf (stderr, "idx: %u\n", ipu->idx);
+  fprintf (stderr, "cu: 0x%x\n", ipu->cu->cu_offset);
+  struct import_edge *e1;
+  for (e1 = ipu->incoming; e1; e1 = e1->next)
+    fprintf (stderr, "incoming: %u\n", e1->icu->idx);
+  for (e1 = ipu->outgoing; e1; e1 = e1->next)
+    fprintf (stderr, "outgoing: %u\n", e1->icu->idx);
+}
+
+static void
+dump_edges (const char *msg, struct import_cu **ipus, unsigned int npus,
+	    unsigned int ncus)
+{
+  struct import_cu *ipu;
+  unsigned int i;
+  fprintf (stderr, "PRINT_EDGES: %s\n", msg);
+  fprintf (stderr, "PUs\n");
+  for (ipu = ipus[0]; ipu; ipu = ipu->next)
+    dump_edges_1 (ipu);
+  fprintf (stderr, "CUs\n");
+  for (i = 0; i < ncus; i++)
+    dump_edges_1 (ipus[i + npus]);
+}
+
+/* Enumerate the different kinds of nodes in the import_cu/import_edge
+   graph.  */
+enum node_kind { NODE_CU, NODE_PU_INITIAL, NODE_PU_NEW };
+
+/* Return the node kind for node IDX, given that:
+   - [0, NPUS - 1] are initial PUs,
+   - [NPUS, NPUS + NCUS - 1] are CUs, and
+   - [NPUS + NCUS, ] are new PUs.  */
+static enum node_kind
+get_node_kind (unsigned int idx, unsigned int npus, unsigned int ncus)
+{
+  if (idx < npus)
+    return NODE_PU_INITIAL;
+  if (idx < npus + ncus)
+    return NODE_CU;
+  return NODE_PU_NEW;
+}
+
+/* Verify an edge from SRC to DEST during create_import_tree phase PHASE.  */
+static void
+verify_edge (enum node_kind src, enum node_kind dest, unsigned int phase)
+{
+  if (phase == 1)
+    {
+      assert (src == NODE_CU && dest == NODE_PU_INITIAL);
+      return;
+    }
+
+  assert (IMPLIES (src == NODE_CU, dest != NODE_CU));
+
+  if (phase == 2)
+    {
+      assert (IMPLIES (src == NODE_PU_NEW, dest == NODE_PU_INITIAL));
+      assert (src != NODE_PU_INITIAL);
+    }
+  else
+    assert (IMPLIES (src == NODE_PU_NEW, dest != NODE_CU));
+}
+
+/* Helper function for debugging create_import_tree.  Verify
+   various invariants for CU/PU IPU.  */
+static void
+verify_edges_1 (struct import_cu *ipu, unsigned int *ic, unsigned int *oc,
+		enum node_kind kind, unsigned int npus, unsigned int ncus,
+		unsigned int phase)
+{
+  struct import_edge *e1, *e2;
+  unsigned int last_idx, count;
+  enum node_kind kind2;
+
+  for (last_idx = 0, count = 0, e1 = ipu->incoming;
+       e1;
+       last_idx = e1->icu->idx, count++, e1 = e1->next)
+    {
+      /* Verify that incoming edges are in ascending idx order.  */
+      assert (count == 0 || e1->icu->idx > last_idx);
+
+      /* Verify that each incoming edge has a corresponding outgoing edge.  */
+      for (e2 = e1->icu->outgoing; e2; e2 = e2->next)
+	if (e2->icu == ipu)
+	  break;
+      assert (e2);
+
+      kind2 = get_node_kind (e1->icu->idx, npus, ncus);
+      verify_edge (kind2, kind, phase);
+
+      if (count == ipu->incoming_count - 1)
+	assert (ipu->incoming_tail == e1);
+    }
+
+  /* Verify the number of incoming edges.  */
+  assert (ipu->incoming_count == count);
+
+  for (last_idx = 0, count = 0, e1 = ipu->outgoing;
+       e1;
+       last_idx = e1->icu->idx, count++, e1 = e1->next)
+    {
+      /* Verify that outgoing edges are in ascending idx order.  */
+      assert (count == 0 || e1->icu->idx > last_idx);
+
+      /* Verify that each outgoing edge has a corresponding incoming edge.  */
+      for (e2 = e1->icu->incoming; e2; e2 = e2->next)
+	if (e2->icu == ipu)
+	  break;
+      assert (e2);
+
+      kind2 = get_node_kind (e1->icu->idx, npus, ncus);
+      verify_edge (kind, kind2, phase);
+    }
+
+  /* Verify the number of outgoing edges.  */
+  assert (ipu->outgoing_count == count);
+
+  *ic += ipu->incoming_count;
+  *oc += ipu->outgoing_count;
+}
+
+/* Helper function for debugging create_import_tree.  Call verify_edges_1
+   on all CUs and PUs.  */
+static void
+verify_edges (struct import_cu **ipus, unsigned int npus, unsigned int ncus,
+	      unsigned int phase)
+{
+  struct import_cu *ipu;
+  unsigned int i, ic, oc;
+
+  ic = 0;
+  oc = 0;
+
+  /* Verify initial PUs.  */
+  ipu = NULL;
+  for (i = 0; i < npus; ++i)
+    {
+      ipu = ipus[i];
+      assert (ipu->cu != NULL);
+      if (i < npus - 1)
+	assert (ipu->next == ipus[i + 1]);
+      assert (ipu->incoming != NULL);
+      if (phase <= 2)
+	assert (ipu->outgoing == NULL);
+      verify_edges_1 (ipu, &ic, &oc, NODE_PU_INITIAL, npus, ncus, phase);
+    }
+
+  /* Verify new PUs.  */
+  assert (ipu != NULL);
+  for (ipu = ipu->next; ipu; ipu = ipu->next)
+    {
+      assert (phase != 1);
+      assert (ipu->cu == NULL);
+      assert (ipu->incoming != NULL);
+      assert (ipu->outgoing != NULL);
+      verify_edges_1 (ipu, &ic, &oc, NODE_PU_NEW, npus, ncus, phase);
+    }
+
+  /* Verify CUs.  */
+  for (i = 0; i < ncus; i++)
+    {
+      ipu = ipus[npus + i];
+      assert (ipu->cu != NULL);
+      assert (ipu->next == NULL);
+      assert (ipu->incoming == NULL);
+      assert (ipu->outgoing != NULL);
+      verify_edges_1 (ipu, &ic, &oc, NODE_CU, npus, ncus, phase);
+    }
+
+  /* Verify that the overall number of incoming and outgoing edges is
+     equal.  */
+  assert (ic == oc);
+}
+
+#define BITVECTOR_TYPE unsigned int
+
+/* Return a bitvector containing NBITS bits.  */
+static inline BITVECTOR_TYPE *
+bitvector_alloc (unsigned nbits)
+{
+  size_t nbytes = (nbits / 8) + 1;
+  size_t size = nbytes + sizeof (BITVECTOR_TYPE);
+  BITVECTOR_TYPE *res = (BITVECTOR_TYPE *)malloc (size);
+  if (res == NULL)
+    dwz_oom ();
+  memset (res, 0, size);
+  return res;
+}
+
+/* Set bit IDX in bitvector VECTOR.  */
+static inline void FORCE_INLINE
+bitvector_set_bit (BITVECTOR_TYPE *vector, unsigned idx)
+{
+  unsigned div = idx / (sizeof (BITVECTOR_TYPE) * 8);
+  unsigned mod = idx % (sizeof (BITVECTOR_TYPE) * 8);
+  vector[div] |= (1U << mod);
+}
+
+/* Test bit IDX in bitvector VECTOR.  */
+static inline bool FORCE_INLINE
+bitvector_bit_p (BITVECTOR_TYPE *vector, unsigned idx)
+{
+  unsigned div = idx / (sizeof (BITVECTOR_TYPE) * 8);
+  unsigned mod = idx % (sizeof (BITVECTOR_TYPE) * 8);
+  return (vector[div] & (1U << mod)) != 0;
+}
+
+/* Clear at least bits [A, B] in VECTOR, possibly more.  */
+static inline void FORCE_INLINE
+bitvector_clear_bits (BITVECTOR_TYPE *vector, unsigned int a, unsigned int b)
+{
+  unsigned int range_min = a / (sizeof (BITVECTOR_TYPE) * 8);
+  unsigned int range_max = b / (sizeof (BITVECTOR_TYPE) * 8);
+  memset (&vector[range_min], 0,
+	  (range_max - range_min + 1) * sizeof (BITVECTOR_TYPE));
+}
+
+/* Function to optimize the size of DW_TAG_imported_unit DIEs by
+   creating an inclusion tree, instead of each CU importing all
+   PUs it needs directly, by optionally creating new PUs or
+   adding DW_TAG_imported_unit to the already created PUs.
+   At the end this function constructs any new PUs needed, and
+   adds DW_TAG_imported_unit DIEs to them as well as the CUs
+   and partition_dups created PUs.  */
+static int
+create_import_tree (void)
+{
+  dw_cu_ref pu, cu, last_partial_cu = NULL;
+  unsigned int i, new_pu_version = 2, min_cu_version, npus, ncus;
+  struct import_cu **ipus, *ipu, *icu;
+  unsigned int cu_off;
+  unsigned int puidx;
+  struct import_cu *last_pu, *pu_freelist = NULL;
+  unsigned char *to_free;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "create_import_tree phase 1\n");
+    }
+
+  /* size doesn't count anything already created before this
+     function (partial units etc.) or already preexisting, just
+     initially the cumulative sizes of DW_TAG_imported_unit DIEs
+     that would need to be added, and if some new DW_TAG_partial_unit
+     CUs are going to be created as a result of this routine, that size
+     too.  DW_TAG_imported_unit has size 5 (for DWARF3+) or 1 + ptr_size
+     (DWARF2), DW_TAG_partial_unit has size 13/14 (11 CU header + 1 byte
+     abbrev number + 1 byte child end + 1 byte for DWARF5 unit_type).  */
+  unsigned int size = 0;
+  /* Size of DW_TAG_imported_unit if the same everywhere, otherwise
+     (mixing DWARF2 and DWARF3+ with ptr_size != 4) 0.  */
+  unsigned int edge_cost = 0;
+  /* Number of bytes needed for outgoing edges of PUs created by
+     this function (which all have DWARF version new_pu_version).  */
+  unsigned int new_edge_cost;
+
+  /* If no PUs were created, there is nothing to do here.  */
+  if (first_cu == NULL || (fi_multifile ? alt_first_cu == NULL
+			   : first_cu->cu_kind != CU_PU))
+    return 0;
+
+  edge_freelist = NULL;
+  to_free = obstack_alloc (&ob2, 1);
+  min_cu_version = first_cu->cu_version;
+  /* First construct a bipartite graph between CUs and PUs.  */
+  for (pu = fi_multifile ? alt_first_cu : first_cu, npus = 0;
+       pu && pu->cu_kind != CU_NORMAL; pu = pu->cu_next)
+    {
+      dw_die_ref die, rdie;
+      dw_cu_ref prev_cu;
+
+      if (pu->cu_die->die_tag == DW_TAG_compile_unit)
+	continue;
+
+      last_partial_cu = pu;
+      for (rdie = pu->cu_die->die_child;
+	   rdie->die_named_namespace; rdie = rdie->die_child)
+	;
+      if (unlikely (fi_multifile) && rdie->die_nextdup == NULL)
+	{
+	  pu->u1.cu_icu = NULL;
+	  continue;
+	}
+      npus++;
+      if (pu->cu_version > new_pu_version)
+	new_pu_version = pu->cu_version;
+      if (pu->cu_version < min_cu_version)
+	min_cu_version = pu->cu_version;
+      ipu = (struct import_cu *) obstack_alloc (&ob2, sizeof (*ipu));
+      memset (ipu, 0, sizeof (*ipu));
+      ipu->cu = pu;
+      pu->u1.cu_icu = ipu;
+      assert (rdie->die_toplevel);
+      dw_die_ref firstdie = NULL;
+      dw_cu_ref firstdiecu = NULL;
+      for (die = rdie->die_nextdup, prev_cu = NULL;
+	   die; die = die->die_nextdup)
+	{
+	  dw_cu_ref diecu = die_cu (die);
+	  if (firstdie == NULL)
+	    {
+	      firstdie = die;
+	      firstdiecu = die_cu (firstdie);
+	    }
+	  if (diecu == prev_cu || (die != firstdie && diecu == firstdiecu))
+	    continue;
+	  ipu->incoming_count++;
+	  size += 1 + (diecu->cu_version == 2 ? ptr_size : 4);
+	  prev_cu = diecu;
+	}
+      ipu->incoming = (struct import_edge *)
+		       obstack_alloc (&ob2,
+				      ipu->incoming_count
+				      * sizeof (*ipu->incoming));
+      firstdie = NULL;
+      firstdiecu = NULL;
+      for (die = rdie->die_nextdup, i = 0, prev_cu = NULL;
+	   die; die = die->die_nextdup)
+	{
+	  dw_cu_ref diecu = die_cu (die);
+	  if (firstdie == NULL)
+	    {
+	      firstdie = die;
+	      firstdiecu = die_cu (firstdie);
+	    }
+	  if (diecu == prev_cu || (die != firstdie && diecu == firstdiecu))
+	    continue;
+	  icu = diecu->u1.cu_icu;
+	  if (icu == NULL)
+	    {
+	      icu = (struct import_cu *)
+		    obstack_alloc (&ob2, sizeof (*ipu));
+	      memset (icu, 0, sizeof (*icu));
+	      icu->cu = diecu;
+	      diecu->u1.cu_icu = icu;
+	    }
+	  ipu->incoming[i++].icu = icu;
+	  icu->outgoing_count++;
+	  prev_cu = diecu;
+	}
+      ipu->incoming_tail = &ipu->incoming[ipu->incoming_count - 1];
+    }
+  if (npus == 0)
+    {
+      obstack_free (&ob2, to_free);
+      return 0;
+    }
+  for (cu = fi_multifile ? first_cu : pu, ncus = 0; cu; cu = cu->cu_next)
+    if (cu->u1.cu_icu)
+      {
+	ncus++;
+	if (cu->cu_version > new_pu_version)
+	  new_pu_version = cu->cu_version;
+	if (cu->cu_version < min_cu_version)
+	  min_cu_version = cu->cu_version;
+	cu->u1.cu_icu->outgoing
+	  = (struct import_edge *)
+	    obstack_alloc (&ob2,
+			   cu->u1.cu_icu->outgoing_count
+			   * sizeof (*cu->u1.cu_icu->outgoing));
+	cu->u1.cu_icu->outgoing_count = 0;
+      }
+  if (ptr_size == 4 || min_cu_version > 2)
+    edge_cost = 5;
+  else if (new_pu_version == 2)
+    edge_cost = 1 + ptr_size;
+  new_edge_cost = new_pu_version == 2 ? 1 + ptr_size : 5;
+  for (pu = fi_multifile ? alt_first_cu : first_cu;
+       pu && pu->cu_kind != CU_NORMAL; pu = pu->cu_next)
+    {
+      ipu = pu->u1.cu_icu;
+      if (ipu == NULL)
+	continue;
+      for (i = 0; i < ipu->incoming_count; i++)
+	{
+	  icu = ipu->incoming[i].icu;
+	  icu->outgoing[icu->outgoing_count++].icu = ipu;
+	}
+    }
+  ipus = (struct import_cu **)
+	 obstack_alloc (&ob2, (npus + ncus) * sizeof (*ipus));
+  for (pu = fi_multifile ? alt_first_cu : first_cu, npus = 0;
+       pu && pu->cu_kind != CU_NORMAL; pu = pu->cu_next)
+    {
+      ipu = pu->u1.cu_icu;
+      if (ipu == NULL)
+	continue;
+      qsort (ipu->incoming, ipu->incoming_count, sizeof (*ipu->incoming),
+	     import_edge_cmp);
+      for (i = 0; i < ipu->incoming_count; i++)
+	{
+	  ipu->incoming[i].next
+	    = i != ipu->incoming_count - 1 ? &ipu->incoming[i + 1] : NULL;
+	}
+      ipus[npus++] = ipu;
+    }
+  for (cu = fi_multifile ? first_cu : pu, ncus = 0; cu; cu = cu->cu_next)
+    if (cu->u1.cu_icu)
+      {
+	icu = cu->u1.cu_icu;
+	qsort (icu->outgoing, icu->outgoing_count, sizeof (*icu->outgoing),
+	       import_edge_cmp);
+	for (i = 0; i < icu->outgoing_count - 1; i++)
+	  icu->outgoing[i].next = &icu->outgoing[i + 1];
+	icu->outgoing[i].next = NULL;
+	ipus[npus + ncus] = icu;
+	ncus++;
+      }
+  qsort (ipus, npus, sizeof (*ipus), import_cu_cmp);
+  qsort (ipus + npus, ncus, sizeof (*ipus), import_cu_cmp);
+  for (puidx = 0; puidx < npus; puidx++)
+    {
+      ipus[puidx]->idx = puidx;
+      if (puidx + 1 < npus)
+	ipus[puidx]->next = ipus[puidx + 1];
+    }
+  for (; puidx < npus + ncus; puidx++)
+    ipus[puidx]->idx = puidx;
+  last_pu = ipus[npus - 1];
+  if (unlikely (dump_edges_p))
+    dump_edges ("phase 1", ipus, npus, ncus);
+  if (unlikely (verify_edges_p))
+    verify_edges (ipus, npus, ncus, 1);
+  if (!import_opt_p)
+    goto opt_done;
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "create_import_tree phase 2\n");
+    }
+  /* Now, for the above constructed bipartite graph, find K x,2 components
+     where x >= 5 (for DWARF3 and above or ptr_size 4, for DWARF2 and
+     ptr_size 8 it can be even x == 4) and add a new PU node, where all
+     CUs from the component will point to the new PU node and that new PU
+     will point to all the destination PUs.  In theory with DWARF2
+     and ptr_size 1 we could need x >= 9.
+
+     The example below demonstrates the type of transformation.  The
+     transformation is an optimization if the benefit of reducing the number
+     of imports (in other words, edges) is bigger than the cost of adding an
+     extra PU.  OTOH, the transformation can be done in the presence of
+     additional incoming edges for PU_3 and PU_4.
+
+     Before:                    After:
+
+     CU_1---------->PU_3        CU_1                PU_3
+         \          ^  ^            \               ^
+          \        /  /              \             /
+           \      /  /                \           /
+            x----o  /                  \         /
+           / \     /                    \       /
+          /   \   /                      \     /
+         /     \ /                        v   /
+     CU_2       x               CU_2----->PU_5
+         \     / \                        ^   \
+          \   /   \                      /     \
+           \ /     \                    /       \
+            x----o  \                  /         \
+           /      \  \                /           \
+          /        \  \              /             \
+         /          v  v            /               v
+     CU_3---------->PU_4        CU_3                PU_4
+  */
+  for (i = 0; i < npus - 1; i++)
+    {
+      struct import_cu *pudst[2], *pusrc[10];
+      struct import_edge *e1, *e2, *e3, *e4;
+      struct import_edge *e1next, *e2next, *e3next;
+      pudst[0] = ipus[i];
+      for (e1 = pudst[0]->incoming; e1; e1 = e1next)
+	{
+	  e1next = e1->next;
+	  if (e1->icu->cu == NULL)
+	    break;
+	  for (e2 = e1->icu->outgoing; e2; e2 = e2next)
+	    {
+	      unsigned int srccount, dstcount, cost;
+	      struct import_cu *npu = NULL;
+	      struct import_edge **ep = NULL;
+
+	      e2next = e2->next;
+	      if (e2->icu->idx <= pudst[0]->idx)
+		continue;
+	      if (e2->icu->cu == NULL)
+		break;
+
+	      pudst[1] = e2->icu;
+	      pusrc[0] = e1->icu;
+	      srccount = 1;
+	      cost = edge_cost;
+	      if (!edge_cost)
+		cost = pusrc[0]->cu->cu_version == 2 ? 1 + ptr_size : 5;
+	      for (e3 = e1next; e3; e3 = e3next)
+		{
+		  e3next = e3->next;
+		  if (e3->icu->cu == NULL)
+		    break;
+		  dstcount = 0;
+		  for (e4 = e3->icu->outgoing; e4; e4 = e4->next)
+		    {
+		      if (e4->icu == pudst[0])
+			dstcount++;
+		      else if (e4->icu == pudst[1])
+			{
+			  dstcount++;
+			  break;
+			}
+		      else if (e4->icu->idx > pudst[1]->idx)
+			break;
+		    }
+		  if (dstcount != 2)
+		    continue;
+		  if (npu == NULL)
+		    {
+		      unsigned int header_size;
+		      pusrc[srccount] = e3->icu;
+		      header_size = (pusrc[srccount]->cu->cu_version >= 5
+				     ? 14 : 13); /* DWARF5 unit_type byte.  */
+		      cost += edge_cost;
+		      if (!edge_cost)
+			cost += pusrc[srccount]->cu->cu_version == 2
+				? 1 + ptr_size : 5;
+		      srccount++;
+		      if (ignore_size || ((dstcount - 1) * cost
+					  > (header_size
+					     + dstcount * new_edge_cost)))
+			{
+			  unsigned int j;
+
+			  e2next = NULL;
+			  if (pu_freelist)
+			    {
+			      npu = pu_freelist;
+			      pu_freelist = pu_freelist->next;
+			    }
+			  else
+			    npu = (struct import_cu *)
+				  obstack_alloc (&ob2, sizeof (*npu));
+			  memset (npu, 0, sizeof (*npu));
+			  npu->incoming_count = srccount;
+			  npu->outgoing_count = dstcount;
+			  npu->idx = puidx++;
+			  last_pu->next = npu;
+			  last_pu = npu;
+			  for (j = 0; j < srccount; j++)
+			    {
+			      if (e1next && e1next->icu == pusrc[j])
+				e1next = e1next->next;
+			      remove_import_edges (&pusrc[j]->outgoing, NULL,
+						   pudst, dstcount, true)->icu
+				= npu;
+			      pusrc[j]->outgoing_count -= dstcount - 1;
+			    }
+			  for (j = 0; j < dstcount; j++)
+			    {
+			      remove_import_edges (&pudst[j]->incoming,
+						   &pudst[j]->incoming_tail,
+						   pusrc, srccount, true)->icu
+				= npu;
+			      pudst[j]->incoming_count -= srccount - 1;
+			    }
+			  npu->incoming = first_edge_from_freelist ();
+			  for (j = 0, e4 = npu->incoming; j < srccount; j++)
+			    {
+			      e4->icu = pusrc[j];
+			      if (j == srccount - 1)
+				{
+				  npu->incoming
+				    = last_edge_from_freelist (npu->incoming,
+							       e4);
+				  npu->incoming_tail = e4;
+				  ep = &e4->next;
+				}
+			      else
+				e4 = e4->next;
+			    }
+			  npu->outgoing = first_edge_from_freelist ();
+			  for (j = 0, e4 = npu->outgoing; j < dstcount; j++)
+			    {
+			      e4->icu = pudst[j];
+			      if (j == dstcount - 1)
+				npu->outgoing
+				  = last_edge_from_freelist (npu->outgoing, e4);
+			      else
+				e4 = e4->next;
+			    }
+			  size -= (dstcount - 1) * cost;
+			  size += 13 + dstcount * new_edge_cost;
+			}
+		    }
+		  else
+		    {
+		      unsigned int j;
+
+		      pusrc[srccount] = e3->icu;
+		      cost = edge_cost;
+		      if (!edge_cost)
+			cost = pusrc[srccount]->cu->cu_version == 2
+			       ? 1 + ptr_size : 5;
+		      if (e1next && e1next->icu == pusrc[srccount])
+			e1next = e1next->next;
+		      remove_import_edges (&pusrc[srccount]->outgoing, NULL,
+					   pudst, dstcount, true)->icu = npu;
+		      pusrc[srccount]->outgoing_count -= dstcount - 1;
+		      for (j = 0; j < dstcount; j++)
+			{
+			  remove_import_edges (&pudst[j]->incoming,
+					       &pudst[j]->incoming_tail,
+					       pusrc + srccount, 1, false);
+			  pudst[j]->incoming_count--;
+			}
+		      *ep = edge_from_freelist ();
+		      npu->incoming_count++;
+		      (*ep)->icu = pusrc[srccount];
+		      (*ep)->next = NULL;
+		      npu->incoming_tail = *ep;
+		      ep = &(*ep)->next;
+		      size -= (dstcount - 1) * cost;
+		    }
+		}
+	    }
+	}
+    }
+  if (unlikely (dump_edges_p))
+    dump_edges ("phase 2", ipus, npus, ncus);
+  if (unlikely (verify_edges_p))
+    verify_edges (ipus, npus, ncus, 2);
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "create_import_tree phase 3\n");
+    }
+  /* Try to merge PUs which have the same set of referrers if
+     beneficial.
+
+     The example below demonstrates the type of transformation.  The
+     transformation is an optimization because it reduces the number of import
+     statements (in other words, edges) as well as the number of PUs.  It can
+     however not be done if PU_3 or PU_4 have additional incoming edges.
+
+     Before:               After:
+
+     CU_1----->PU_3        CU_1
+         \     ^               \
+          \   /                 \
+           \ /                   v
+            x                    PU_3_4
+           / \                   ^
+          /   \                 /
+         /     v               /
+     CU_2----->PU_4        CU_2
+
+     Or, if one PU has a subset of referrers of the other, attempt to replace
+     all the incoming edges from the referrers intersection to the PU with
+     larger number of incoming edges by an edge from the other PU.
+
+     The example below demonstrates the type of transformation.  The
+     transformation is an optimization because it reduces the number of import
+     statements (in other words, edges).  It can however not be done if PU_3
+     has additional incoming edges.
+
+     Before:               After:
+
+     CU_1----->PU_3        CU_1------>PU_3
+         \     ^                      ^  |
+          \   /                      /   |
+           \ /                      /    |
+            x                      /     |
+           / \                    /      |
+          /   \                  /       |
+         /     \                /        |
+     CU_2       \           CU_2         o
+         \       \                       |
+          \       o                      |
+           \      |                      |
+            \     |                      |
+             \    |                      |
+              \   |                      |
+               v  v                      v
+     CU_3----->PU_4        CU_3------>PU_4
+  */
+  /* Flag used during PU merging, set for PUs already considered
+     for merging for the given first PU.  */
+  BITVECTOR_TYPE *seen = bitvector_alloc (puidx);
+  unsigned int min_seen = UINT_MAX;
+  unsigned int max_seen = 0;
+  for (ipu = ipus[0]; ipu; ipu = ipu->next)
+    {
+      struct import_edge *e1, *e2, *e3, *e4, **e1p, **ep, *prev;
+      for (e1p = &ipu->incoming, e1 = *e1p;
+	   e1; e1 = *e1p != e1 ? *e1p : (e1p = &e1->next, e1->next))
+	{
+	  for (e2 = e1->icu->outgoing; e2; e2 = e2->next)
+	    {
+	      unsigned int size_inc, size_dec;
+	      struct import_cu *ipu2 = e2->icu, *ipusub, *ipusup;
+	      /* True if IPU's src set might be a subset
+		 of IPU2's src set.  */
+	      bool maybe_subset;
+	      /* True if IPU's src set might be a superset
+		 of IPU2's src set.  */
+	      bool maybe_superset;
+	      unsigned int intersection;
+
+	      if (ipu2->idx <= ipu->idx || bitvector_bit_p (seen, ipu2->idx))
+		continue;
+	      bitvector_set_bit (seen, ipu2->idx);
+	      min_seen = MIN (min_seen, ipu2->idx);
+	      max_seen = MAX (max_seen, ipu2->idx);
+	      maybe_subset = (e1 == ipu->incoming
+			      && ipu->incoming_count <= ipu2->incoming_count);
+	      maybe_superset = ipu->incoming_count >= ipu2->incoming_count;
+	      if (maybe_superset)
+		{
+		  /* If the referrer nodes of ipu are a superset of the
+		     referrer nodes of ipu2, then ipu's last referrer node
+		     should have index larger or equal to the last referrer
+		     node of ipu2.  */
+		  maybe_superset
+		    = (ipu->incoming_tail->icu->idx
+		       >= ipu2->incoming_tail->icu->idx);
+		}
+	      if (maybe_subset)
+		{
+		  /* If the referrer nodes of ipu are a subset of the
+		     referrer nodes of ipu2, then ipu's last referrer node
+		     should have index smaller or equal to the last referrer
+		     node of ipu2.  */
+		  maybe_subset
+		    = (ipu->incoming_tail->icu->idx
+		       <= ipu2->incoming_tail->icu->idx);
+		}
+	      e3 = e1;
+	      e4 = ipu2->incoming;
+	      intersection = 0;
+	      while ((maybe_subset || maybe_superset) && e3 && e4)
+		{
+		  if (e3->icu == e4->icu)
+		    {
+		      intersection++;
+		      e3 = e3->next;
+		      e4 = e4->next;
+		      continue;
+		    }
+		  if (e3->icu->idx < e4->icu->idx)
+		    {
+		      maybe_subset = false;
+		      e3 = e3->next;
+		      continue;
+		    }
+		  maybe_superset = false;
+		  e4 = e4->next;
+		}
+	      if (e3)
+		maybe_subset = false;
+	      if (e4)
+		maybe_superset = false;
+	      if ((!maybe_superset && !maybe_subset) || intersection < 2)
+		continue;
+	      if (maybe_superset && maybe_subset)
+		{
+		  if (unlikely (fi_multifile) && ipu2->idx < npus + ncus)
+		    continue;
+		  if (odr_active_p && odr_mode != ODR_BASIC
+		      && ipu2->idx < npus + ncus)
+		    continue;
+		  /* If IPU and IPU2 have the same set of src nodes, then
+		     (if beneficial, with edge_cost != 0 always), merge
+		     IPU2 node into IPU, by removing all incoming edges
+		     of IPU2 and moving over all outgoing edges of IPU2
+		     to IPU.  */
+		  assert (ipu2->idx >= npus + ncus);
+		  size_inc = 0;
+		  if (edge_cost)
+		    size_dec = 13 + ipu2->incoming_count * edge_cost;
+		  else
+		    {
+		      size_dec = 13;
+		      if (ipu->cu && ipu->cu->cu_version == 2)
+			{
+			  if (ptr_size > 4)
+			    size_inc = ipu2->outgoing_count * (ptr_size - 4);
+			  else
+			    size_dec += ipu2->outgoing_count * (4 - ptr_size);
+			}
+		      for (e4 = ipu2->incoming; e4; e4 = e4->next)
+			size_dec += (e4->icu->cu
+				     && e4->icu->cu->cu_version == 2)
+				    ? 1 + ptr_size : 5;
+		    }
+		  if (!ignore_size || size_dec > size_inc)
+		    {
+		      struct import_cu **ipup;
+		      for (e4 = ipu2->incoming, e3 = NULL; e4; e4 = e4->next)
+			{
+			  remove_import_edges (&e4->icu->outgoing, NULL, &ipu2,
+					       1, false);
+			  e4->icu->outgoing_count--;
+			  prepare_free_edge (e4);
+			  e3 = e4;
+			}
+		      free_edges (ipu2->incoming, e3);
+		      for (e4 = ipu2->outgoing; e4; e4 = e4->next)
+			{
+			  for (ep = &e4->icu->incoming; *ep; ep = &(*ep)->next)
+			    if ((*ep)->icu->idx >= ipu->idx)
+			      break;
+			  assert ((*ep)->icu != ipu);
+			  if ((*ep)->icu == ipu2)
+			    (*ep)->icu = ipu;
+			  else
+			    {
+			      struct import_edge **ep2;
+			      for (ep2 = &(*ep)->next;
+				   *ep2; ep2 = &(*ep2)->next)
+				if ((*ep2)->icu == ipu2)
+				  break;
+			      e3 = *ep2;
+			      *ep2 = e3->next;
+			      e3->next = *ep;
+			      *ep = e3;
+			      e3->icu = ipu;
+			      while (e4->icu->incoming_tail->next != NULL)
+				e4->icu->incoming_tail
+				  = e4->icu->incoming_tail->next;
+			    }
+			}
+		      e3 = ipu->outgoing;
+		      ep = &ipu->outgoing;
+		      for (e4 = ipu2->outgoing; e3 && e4; )
+			if (e3->icu->idx < e4->icu->idx)
+			  {
+			    *ep = e3;
+			    ep = &e3->next;
+			    e3 = e3->next;
+			  }
+			else
+			  {
+			    assert (e3->icu != e4->icu);
+			    *ep = e4;
+			    ep = &e4->next;
+			    e4 = e4->next;
+			  }
+		      if (e3)
+			*ep = e3;
+		      else if (e4)
+			*ep = e4;
+		      else
+			*ep = NULL;
+		      ipu->outgoing_count += ipu2->outgoing_count;
+		      size -= size_dec - size_inc;
+		      if (ipu->idx >= npus + ncus)
+			ipup = &ipu->next;
+		      else
+			ipup = &ipus[npus - 1]->next;
+		      while (*ipup != ipu2)
+			ipup = &(*ipup)->next;
+		      *ipup = ipu2->next;
+		      ipu2->next = pu_freelist;
+		      pu_freelist = ipu2;
+		      continue;
+		    }
+		}
+	      if (maybe_superset)
+		{
+		  ipusup = ipu;
+		  ipusub = ipu2;
+		}
+	      else
+		{
+		  ipusub = ipu;
+		  ipusup = ipu2;
+		}
+	      /* If IPUSUB's src set is a subset of IPUSUP's src set
+		 and intersection is at least 2, remove edges from
+		 IPUSUB's src set to IPUSUP node and instead add
+		 an edge from IPUSUB to IPUSUP.  */
+	      size_inc = 0;
+	      if (edge_cost)
+		size_dec = (ipusub->incoming_count - 1) * edge_cost;
+	      else
+		{
+		  size_inc = ipusub->cu && ipusub->cu->cu_version == 2
+			     ? 1 + ptr_size : 5;
+		  size_dec = 0;
+		  for (e3 = ipusub->incoming; e3; e3 = e3->next)
+		    size_dec += (e3->icu->cu
+				 && e3->icu->cu->cu_version == 2)
+				? 1 + ptr_size : 5;
+		}
+	      if (size_dec > size_inc
+		  && (!fi_multifile || ipusub->idx >= npus + ncus))
+		{
+		  for (e3 = ipusub->incoming, ep = &ipusup->incoming,
+			 prev = NULL;
+		       e3; e3 = e3->next)
+		    {
+		      remove_import_edges (&e3->icu->outgoing, NULL, &ipusup, 1,
+					   false);
+		      e3->icu->outgoing_count--;
+		      while ((*ep)->icu != e3->icu)
+			{
+			    prev = *ep;
+			    ep = &(*ep)->next;
+			}
+		      e4 = *ep;
+		      *ep = e4->next;
+		      free_edge (e4);
+		      if (ipusup->incoming_tail == e4)
+			ipusup->incoming_tail  = prev;
+		    }
+		  for (ep = &ipusub->outgoing; *ep; ep = &(*ep)->next)
+		    if ((*ep)->icu->idx >= ipusup->idx)
+		      break;
+		  assert (*ep == NULL || (*ep)->icu != ipusup);
+		  e4 = edge_from_freelist ();
+		  e4->icu = ipusup;
+		  e4->next = *ep;
+		  *ep = e4;
+		  ipusub->outgoing_count++;
+		  for (ep = &ipusup->incoming; *ep; ep = &(*ep)->next)
+		    if ((*ep)->icu->idx >= ipusub->idx)
+		      break;
+		  assert (*ep == NULL || (*ep)->icu != ipusub);
+		  e4 = edge_from_freelist ();
+		  e4->icu = ipusub;
+		  e4->next = *ep;
+		  *ep = e4;
+		  if (ipusup->incoming_tail->next == e4)
+		    ipusup->incoming_tail = e4;
+		  ipusup->incoming_count -= ipusub->incoming_count - 1;
+		  size -= size_dec - size_inc;
+		  if (ipusup == ipu)
+		    break;
+		}
+	    }
+	}
+      if (min_seen <= max_seen)
+	{
+	  bitvector_clear_bits (seen, min_seen, max_seen);
+	  min_seen = UINT_MAX;
+	  max_seen = 0;
+	}
+    }
+  free (seen);
+  if (unlikely (dump_edges_p))
+    dump_edges ("phase 3", ipus, npus, ncus);
+  if (unlikely (verify_edges_p))
+    verify_edges (ipus, npus, ncus, 3);
+ opt_done:
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "create_import_tree phase 4 (create partial units)\n");
+    }
+  /* Create DW_TAG_partial_unit (and containing dw_cu structures).  */
+  if (fi_multifile)
+    {
+      cu_off = 0;
+      last_partial_cu = NULL;
+    }
+  else
+    cu_off = last_partial_cu->cu_offset + 1;
+  for (ipu = ipus[npus - 1]->next; ipu; ipu = ipu->next)
+    {
+      dw_die_ref die;
+      dw_cu_ref partial_cu = pool_alloc (dw_cu, sizeof (struct dw_cu));
+      memset (partial_cu, '\0', sizeof (*partial_cu));
+      partial_cu->cu_kind = CU_PU;
+      partial_cu->cu_offset = cu_off++;
+      partial_cu->cu_version = new_pu_version;
+      partial_cu->u1.cu_icu = ipu;
+      if (unlikely (last_partial_cu == NULL))
+	{
+	  partial_cu->cu_next = first_cu;
+	  first_cu = partial_cu;
+	}
+      else
+	{
+	  partial_cu->cu_next = last_partial_cu->cu_next;
+	  last_partial_cu->cu_next = partial_cu;
+	}
+      last_partial_cu = partial_cu;
+      die = pool_alloc (dw_die, sizeof (struct dw_die));
+      memset (die, '\0', sizeof (struct dw_die));
+      die->die_toplevel = 1;
+      partial_cu->cu_die = die;
+      die->die_tag = DW_TAG_partial_unit;
+      die->die_offset = -1U;
+      die->die_root = 1;
+      die->die_parent = (dw_die_ref) partial_cu;
+      die->die_size = 1;
+      ipu->cu = partial_cu;
+    }
+  /* Next add all needed DW_TAG_imported_unit DIEs.  */
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    {
+      struct import_edge *e;
+
+      icu = cu->u1.cu_icu;
+      if (icu == NULL)
+	continue;
+      for (e = icu->outgoing; e; e = e->next)
+	{
+	  dw_die_ref *diep;
+	  dw_die_ref die = pool_alloc (dw_die, sizeof (struct dw_die));
+	  memset (die, '\0', sizeof (*die));
+	  die->die_toplevel = 1;
+	  die->die_tag = DW_TAG_imported_unit;
+	  die->die_offset = -1U;
+	  die->die_nextdup = e->icu->cu->cu_die;
+	  die->die_parent = cu->cu_die;
+	  assert (e->icu->cu->cu_die->die_tag == DW_TAG_partial_unit);
+	  die->die_size = (cu->cu_version == 2 ? 1 + ptr_size : 5);
+	  /* Put the new DW_TAG_imported_unit DIE after all typed DWARF
+	     stack referenced base types and after all previously added
+	     new DW_TAG_imported_unit DIEs.  */
+	  for (diep = &die->die_parent->die_child;
+	       *diep; diep = &(*diep)->die_sib)
+	    if (!(*diep)->die_op_type_referenced
+		&& ((*diep)->die_tag != DW_TAG_imported_unit
+		    || (*diep)->die_offset != -1U))
+	      break;
+	  die->die_sib = *diep;
+	  *diep = die;
+	}
+    }
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    cu->u1.cu_icu = NULL;
+  if (unlikely (fi_multifile))
+    for (cu = alt_first_cu; cu; cu = cu->cu_next)
+      cu->u1.cu_icu = NULL;
+  obstack_free (&ob2, to_free);
+  return 0;
+}
+
+/* Helper function for die_find_dup, when ORIG has collapsed children.  */
+static dw_die_ref
+die_find_collapsed_dup (dw_die_ref die, unsigned int *tick)
+{
+  dw_die_ref child, ret;
+
+  for (child = die->die_child; child; child = child->die_sib)
+    if ((*tick)-- == 0)
+      return child;
+    else if (child->die_child == NULL)
+      continue;
+    else if ((ret = die_find_collapsed_dup (child, tick)) != NULL)
+      return ret;
+  (*tick)--;
+  return NULL;
+}
+
+/* If DIE is equal to ORIG, return DUP, otherwise if DIE is
+   a child of ORIG, return corresponding child in DUP's subtree,
+   or return NULL.  */
+static dw_die_ref
+die_find_dup (dw_die_ref orig, dw_die_ref dup, dw_die_ref die)
+{
+  dw_die_ref orig_child, dup_child;
+  if (orig == die)
+    return dup;
+  if (orig->die_collapsed_children)
+    {
+      dw_die_ref ret;
+      unsigned int tick;
+      if (die->die_collapsed_child)
+	tick = die->die_tag - 1;
+      else
+	tick = die->die_ref_seen - 1;
+      assert (dup->die_collapsed_children == 0
+	      && die->die_parent == orig);
+      ret = die_find_collapsed_dup (dup, &tick);
+      assert (die->die_collapsed_child || ret->die_tag == die->die_tag);
+      return ret;
+    }
+  for (orig_child = orig->die_child, dup_child = dup->die_child;
+       orig_child;
+       orig_child = orig_child->die_sib, dup_child = dup_child->die_sib)
+    {
+      dw_die_ref ret = die_find_dup (orig_child, dup_child, die);
+      if (ret)
+	return ret;
+    }
+  return NULL;
+}
+
+/* Return number of bytes needed to encode VAL using
+   uleb128.  */
+static unsigned int
+size_of_uleb128 (uint64_t val)
+{
+  unsigned int size;
+  for (size = 1; (val >>= 7) != 0; size++)
+    ;
+  return size;
+}
+
+/* Return number of bytes needed to encode VAL using
+   sleb128.  */
+static unsigned int
+size_of_sleb128 (int64_t val)
+{
+  unsigned int size = 0;
+  unsigned char c;
+  do
+    {
+      c = val & 0x7f;
+      val >>= 7;
+      size++;
+    }
+  while ((val != 0 || (c & 0x40) != 0)
+	 && (val != -1 || (c & 0x40) == 0));
+  return size;
+}
+
+/* Hash table mapping original file IDs to new ids.  */
+static htab_t line_htab;
+/* Current new maximum file ID.  */
+static unsigned int max_line_id;
+
+struct line_entry
+{
+  /* File pointer.  */
+  struct dw_file *file;
+  /* Precomputed hash value.  */
+  unsigned int hash;
+  /* Corresponding new file ID.  */
+  unsigned int new_id;
+};
+ALIGN_STRUCT (line_entry)
+
+/* Hash function in line_htab.  */
+static hashval_t
+line_hash (const void *p)
+{
+  struct line_entry *s = (struct line_entry *)p;
+
+  return s->hash;
+}
+
+/* Equality function in line_htab.  */
+static int
+line_eq (const void *p, const void *q)
+{
+  struct line_entry *s1 = (struct line_entry *)p;
+  struct line_entry *s2 = (struct line_entry *)q;
+
+  if (s1->hash != s2->hash)
+    return 0;
+  if (s1->file == s2->file)
+    return 1;
+  if (strcmp (s1->file->file, s2->file->file) != 0)
+    return 0;
+  if ((s1->file->dir == NULL) ^ (s2->file->dir == NULL))
+    return 0;
+  if (s1->file->dir && strcmp (s1->file->dir, s2->file->dir) != 0)
+    return 0;
+  return s1->file->time == s2->file->time && s1->file->size == s2->file->size;
+}
+
+/* Map original file ID to new file ID.  */
+static unsigned int
+line_htab_lookup (dw_cu_ref cu, unsigned int id)
+{
+  void **slot;
+  struct line_entry le;
+  if (id == 0)
+    return 0;
+  assert (id <= cu->cu_nfiles);
+  le.file = &cu->cu_files[id - 1];
+  hash_init_state ();
+  hash_update_state_object (le.file->time);
+  hash_update_state_object (le.file->size);
+  hash_update_state (le.file->file, strlen (le.file->file) + 1);
+  if (le.file->dir)
+    hash_update_state (le.file->dir, strlen (le.file->dir) + 1);
+  if (line_htab == NULL)
+    {
+      line_htab = htab_try_create (50, line_hash, line_eq, NULL);
+      if (line_htab == NULL)
+	dwz_oom ();
+      max_line_id = 1;
+    }
+  le.hash = hash_digest ();
+  slot = htab_find_slot_with_hash (line_htab, &le, le.hash, INSERT);
+  if (slot == NULL)
+    dwz_oom ();
+  if (*slot == NULL)
+    {
+      struct line_entry *l = pool_alloc (line_entry, sizeof (*l));
+      l->file = le.file;
+      l->hash = le.hash;
+      l->new_id = max_line_id++;
+      *slot = (void *) l;
+      return l->new_id;
+    }
+  else
+    return ((struct line_entry *) *slot)->new_id;
+}
+
+/* Hash table for finding duplicate .debug_macro opcode sequences.
+   This hash table is used with two different sets of hash/equality
+   callbacks.  One is used either within handle_macro function (from within
+   optimize_multifile), or from handle_macro onwards (read_multifile).
+   The second set is used from read_macro onwards during fi_multifile.  */
+static htab_t macro_htab;
+
+/* At the end of read_multifile macro_htab is copied to this variable.  */
+static htab_t alt_macro_htab;
+
+struct macro_entry
+{
+  /* Start of the sequence.  */
+  unsigned char *ptr;
+  /* Precomputed hash value.  LSB bit is used for a flag whether
+     a particular .debug_macro sequence is seen more than once.  */
+  unsigned int hash;
+  /* And it's length or 0 if non-shareable.  */
+  unsigned int len;
+};
+ALIGN_STRUCT (macro_entry)
+
+/* Hash function in macro_htab.  */
+static hashval_t
+macro_hash (const void *p)
+{
+  struct macro_entry *m = (struct macro_entry *)p;
+
+  return m->hash & ~1U;
+}
+
+/* Equality function in macro_htab.  */
+static int
+macro_eq (const void *p, const void *q)
+{
+  struct macro_entry *m1 = (struct macro_entry *)p;
+  struct macro_entry *m2 = (struct macro_entry *)q;
+  unsigned char *p1, *p2, *s1, op;
+  unsigned int strp1, strp2;
+
+  if (m1->hash != m2->hash || m1->len != m2->len)
+    return 0;
+  if (rd_multifile)
+    return 0;
+
+  s1 = m1->ptr;
+  p2 = m2->ptr;
+  p1 = s1 + 3;
+
+  while (1)
+    {
+      op = read_8 (p1);
+      if (op == 0)
+	break;
+
+      switch (op)
+	{
+	case DW_MACRO_define:
+	case DW_MACRO_undef:
+	  skip_leb128 (p1);
+	  p1 = (unsigned char *) strchr ((char *) p1, '\0') + 1;
+	  break;
+	case DW_MACRO_define_strp:
+	case DW_MACRO_undef_strp:
+	  skip_leb128 (p1);
+	  if (memcmp (s1, p2, p1 - s1) != 0)
+	    return 0;
+	  p2 += p1 - s1;
+	  strp1 = read_32 (p1);
+	  strp2 = read_32 (p2);
+	  if (op_multifile)
+	    {
+	      if (strcmp ((char *) debug_sections[DEBUG_STR].data + strp1,
+			  (char *) debug_sections[DEBUG_STR].data + strp2)
+		  != 0)
+		return 0;
+	    }
+	  else if (lookup_strp_offset (strp2) != strp1)
+	    return 0;
+	  s1 = p1;
+	  break;
+	default:
+	  abort ();
+	}
+    }
+  return memcmp (s1, p2, p1 - s1) == 0;
+}
+
+/* Hash function in macro_htab.  */
+static hashval_t
+macro_hash2 (const void *p)
+{
+  struct macro_entry *m = (struct macro_entry *)p;
+
+  return m->ptr - debug_sections[DEBUG_MACRO].data;
+}
+
+/* Equality function in macro_htab.  */
+static int
+macro_eq2 (const void *p, const void *q)
+{
+  struct macro_entry *m1 = (struct macro_entry *)p;
+  struct macro_entry *m2 = (struct macro_entry *)q;
+  return m1->ptr == m2->ptr;
+}
+
+/* Parse .debug_macro section, either during write_multifile
+   or during fi_multifile phase.  During write_multifile it
+   selects potentially shareable .debug_macro sequences and
+   writes them into debug_sections[DEBUG_MACRO].new_data
+   block it allocates.  During fi_multifile it populates
+   macro_htab.  In both cases it calls note_strp_offset
+   on DW_FORM_strp offsets.  */
+static int
+read_macro (DSO *dso)
+{
+  unsigned char *ptr, *endsec, *dst = NULL;
+  unsigned int version, flags, op, strp;
+  struct macro_entry me, *m;
+
+  ptr = debug_sections[DEBUG_MACRO].data;
+  endsec = ptr + debug_sections[DEBUG_MACRO].size;
+  debug_sections[DEBUG_MACRO].new_size = 0;
+  if (!wr_multifile)
+    {
+      macro_htab = htab_try_create (50, macro_hash2, macro_eq2, NULL);
+      if (macro_htab == NULL)
+	dwz_oom ();
+    }
+
+  while (ptr < endsec)
+    {
+      unsigned char *start = ptr, *s = ptr;
+      bool can_share = true;
+      hashval_t hash = 0;
+      unsigned int strp;
+      void **slot;
+
+      if (ptr + 4 > endsec)
+	{
+	  error (0, 0, "%s: .debug_macro header too small", dso->filename);
+	  return 1;
+	}
+
+      version = read_16 (ptr);
+      bool supported_version_p = version >= 4 && version <= 5;
+      if (!supported_version_p)
+	{
+	  error (0, 0, "%s: Unhandled .debug_macro version %d", dso->filename,
+		 version);
+	  return 1;
+	}
+      flags = read_8 (ptr);
+      if ((flags & ~2U) != 0)
+	{
+	  error (0, 0, "%s: Unhandled .debug_macro flags %d", dso->filename,
+		 flags);
+	  return 1;
+	}
+      if ((flags & 2) != 0)
+	{
+	  ptr += 4;
+	  can_share = false;
+	}
+      if (fi_multifile && alt_macro_htab == NULL)
+	can_share = false;
+
+      op = -1U;
+      while (ptr < endsec)
+	{
+	  op = read_8 (ptr);
+	  if (op == 0)
+	    break;
+
+	  switch (op)
+	    {
+	    case DW_MACRO_define:
+	    case DW_MACRO_undef:
+	      skip_leb128 (ptr);
+	      ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+	      break;
+	    case DW_MACRO_start_file:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      can_share = false;
+	      break;
+	    case DW_MACRO_end_file:
+	      can_share = false;
+	      break;
+	    case DW_MACRO_define_strp:
+	    case DW_MACRO_undef_strp:
+	      skip_leb128 (ptr);
+	      strp = read_32 (ptr);
+	      note_strp_offset (strp);
+	      if (wr_multifile)
+		break;
+	      if (can_share)
+		hash = iterative_hash (s, ptr - 4 - s, hash);
+	      if (can_share)
+		{
+		  unsigned char *p = debug_sections[DEBUG_STR].data + strp;
+		  unsigned int len = strlen ((char *) p);
+		  hash = iterative_hash (p, len, hash);
+		  s = ptr;
+		}
+	      break;
+	    case DW_MACRO_import:
+	      ptr += 4;
+	      can_share = false;
+	      break;
+	    default:
+	      error (0, 0, "%s: Unhandled .debug_macro opcode 0x%x",
+		     dso->filename, op);
+	      return 1;
+	    }
+	}
+      if (op != 0)
+	{
+	  error (0, 0, "%s: .debug_macro section not zero terminated",
+		 dso->filename);
+	  return 1;
+	}
+      if (wr_multifile)
+	{
+	  if (can_share)
+	    debug_sections[DEBUG_MACRO].new_size += ptr - start;
+	  continue;
+	}
+
+      me.ptr = start;
+      if (can_share)
+	{
+	  hash = iterative_hash (s, ptr - s, hash);
+	  me.hash = hash & ~1U;
+	  me.len = ptr - start;
+	  m = (struct macro_entry *)
+	      htab_find_with_hash (alt_macro_htab, &me, me.hash);
+	  if (m == NULL)
+	    can_share = false;
+	  else
+	    me.hash = m->ptr - alt_data[DEBUG_MACRO];
+	}
+      if (!can_share)
+	{
+	  me.len = 0;
+	  me.hash = debug_sections[DEBUG_MACRO].new_size;
+	  debug_sections[DEBUG_MACRO].new_size += ptr - start;
+	}
+      slot
+	= htab_find_slot_with_hash (macro_htab, &me,
+				    me.ptr - debug_sections[DEBUG_MACRO].data,
+				    INSERT);
+      if (slot == NULL)
+	dwz_oom ();
+      else
+	{
+	  assert (*slot == NULL);
+	  m = pool_alloc (macro_entry, sizeof (*m));
+	  *m = me;
+	  *slot = (void *) m;
+	}
+    }
+
+  if (!wr_multifile)
+    return 0;
+
+  debug_sections[DEBUG_MACRO].new_data
+    = (unsigned char *) malloc (debug_sections[DEBUG_MACRO].new_size);
+  if (debug_sections[DEBUG_MACRO].new_data == NULL)
+    dwz_oom ();
+  dst = debug_sections[DEBUG_MACRO].new_data;
+  for (ptr = debug_sections[DEBUG_MACRO].data; ptr < endsec; )
+    {
+      unsigned char *start = ptr;
+      bool can_share = true;
+
+      ptr += 2;
+      flags = read_8 (ptr);
+      if ((flags & 2) != 0)
+	{
+	  ptr += 4;
+	  can_share = false;
+	}
+
+      while (1)
+	{
+	  op = read_8 (ptr);
+	  if (op == 0)
+	    break;
+
+	  switch (op)
+	    {
+	    case DW_MACRO_define:
+	    case DW_MACRO_undef:
+	      skip_leb128 (ptr);
+	      ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+	      break;
+	    case DW_MACRO_start_file:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      can_share = false;
+	      break;
+	    case DW_MACRO_end_file:
+	      can_share = false;
+	      break;
+	    case DW_MACRO_define_strp:
+	    case DW_MACRO_undef_strp:
+	      skip_leb128 (ptr);
+	      ptr += 4;
+	      break;
+	    case DW_MACRO_import:
+	      ptr += 4;
+	      can_share = false;
+	      break;
+	    default:
+	      abort ();
+	    }
+	}
+      if (can_share)
+	{
+	  ptr = start + 3;
+
+	  while (1)
+	    {
+	      op = read_8 (ptr);
+	      if (op == 0)
+		break;
+
+	      switch (op)
+		{
+		case DW_MACRO_define:
+		case DW_MACRO_undef:
+		  skip_leb128 (ptr);
+		  ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+		  break;
+		case DW_MACRO_define_strp:
+		case DW_MACRO_undef_strp:
+		  skip_leb128 (ptr);
+		  memcpy (dst, start, ptr - start);
+		  dst += ptr - start;
+		  strp = lookup_strp_offset (read_32 (ptr));
+		  write_32 (dst, strp);
+		  start = ptr;
+		  break;
+		default:
+		  abort ();
+		}
+	    }
+	  memcpy (dst, start, ptr - start);
+	  dst += ptr - start;
+	}
+    }
+  assert (dst == debug_sections[DEBUG_MACRO].new_data
+		 + debug_sections[DEBUG_MACRO].new_size);
+
+  return 0;
+}
+
+/* Helper function for handle_macro, called through htab_traverse.
+   Write .debug_macro opcode sequence seen by more than one
+   executable or shared library.  */
+static int
+optimize_write_macro (void **slot, void *data)
+{
+  struct macro_entry *m = (struct macro_entry *) *slot;
+  unsigned char **pp = (unsigned char **) data;
+  unsigned char *s = m->ptr;
+  unsigned char *p = s + 3, *q, op;
+  unsigned int strp;
+
+  if ((m->hash & 1) == 0)
+    return 1;
+  while (1)
+    {
+      op = read_8 (p);
+      if (op == 0)
+	break;
+
+      switch (op)
+	{
+	case DW_MACRO_define:
+	case DW_MACRO_undef:
+	  skip_leb128 (p);
+	  p = (unsigned char *) strchr ((char *) p, '\0') + 1;
+	  break;
+	case DW_MACRO_define_strp:
+	case DW_MACRO_undef_strp:
+	  skip_leb128 (p);
+	  memcpy (*pp, s, p - s);
+	  *pp += p - s;
+	  strp = read_32 (p);
+	  q = *pp;
+	  write_32 (q, lookup_strp_offset (strp));
+	  *pp += 4;
+	  s = p;
+	  break;
+	default:
+	  abort ();
+	}
+    }
+  memcpy (*pp, s, p - s);
+  *pp += p - s;
+  return 1;
+}
+
+/* Parse .debug_macro section, during optimize_multifile
+   or during read_multifile.  It parses .debug_macro written
+   by write_multifile, so it only contains shareable sequences.
+   Find duplicate sequences, during optimize_multifile write them
+   into debug_sections[DEBUG_MACRO].new_data it allocates,
+   during read_multifile just populates macro_htab (soon to be
+   alt_macro_htab).  */
+static void
+handle_macro (void)
+{
+  unsigned char *ptr, *endsec, op;
+  unsigned char *to_free = NULL;
+  struct macro_entry me, *m;
+
+  macro_htab = htab_try_create (50, macro_hash, macro_eq, NULL);
+  if (macro_htab == NULL)
+    dwz_oom ();
+
+  endsec = debug_sections[DEBUG_MACRO].data + debug_sections[DEBUG_MACRO].size;
+  if (op_multifile)
+    {
+      debug_sections[DEBUG_MACRO].new_size = 0;
+      to_free = obstack_alloc (&ob, 1);
+    }
+
+  for (ptr = debug_sections[DEBUG_MACRO].data; ptr < endsec; )
+    {
+      unsigned char *start = ptr, *s = ptr, *p;
+      hashval_t hash = 0;
+      unsigned int len;
+      void **slot;
+      bool can_share = true;
+
+      ptr += 3;
+      while (1)
+	{
+	  op = read_8 (ptr);
+	  if (op == 0)
+	    break;
+
+	  switch (op)
+	    {
+	    case DW_MACRO_define:
+	    case DW_MACRO_undef:
+	      skip_leb128 (ptr);
+	      ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+	      break;
+	    case DW_MACRO_define_strp:
+	    case DW_MACRO_undef_strp:
+	      skip_leb128 (ptr);
+	      hash = iterative_hash (s, ptr - s, hash);
+	      p = debug_sections[DEBUG_STR].data + read_32 (ptr);
+	      len = strlen ((char *) p);
+	      hash = iterative_hash (p, len, hash);
+	      if (op_multifile
+		  /* This should only happen if there were multiple
+		     same transparent units within a single object file.  */
+		  && htab_find_with_hash (strp_htab, p,
+					  hash (p, len)) == NULL)
+		can_share = false;
+	      s = ptr;
+	      break;
+	    default:
+	      abort ();
+	    }
+	}
+      if (!can_share)
+	continue;
+      hash = iterative_hash (s, ptr - s, hash);
+      me.ptr = start;
+      me.hash = hash & ~1U;
+      me.len = ptr - start;
+      slot = htab_find_slot_with_hash (macro_htab, &me, me.hash, INSERT);
+      if (slot == NULL)
+	dwz_oom ();
+      else if (*slot != NULL)
+	{
+	  m = (struct macro_entry *) *slot;
+	  if (op_multifile && (m->hash & 1) == 0)
+	    {
+	      m->hash |= 1;
+	      debug_sections[DEBUG_MACRO].new_size += me.len;
+	    }
+	}
+      else if (op_multifile)
+	{
+	  m = (struct macro_entry *) obstack_alloc (&ob, sizeof (*m));
+	  *m = me;
+	  *slot = (void *) m;
+	}
+      else
+	{
+	  m = pool_alloc (macro_entry, sizeof (*m));
+	  *m = me;
+	  *slot = (void *) m;
+	}
+    }
+
+  if (op_multifile)
+    {
+      if (debug_sections[DEBUG_MACRO].new_size)
+	{
+	  unsigned char *p;
+	  debug_sections[DEBUG_MACRO].new_data
+	    = malloc (debug_sections[DEBUG_MACRO].new_size);
+	  p = debug_sections[DEBUG_MACRO].new_data;
+	  htab_traverse (macro_htab, optimize_write_macro, &p);
+	  assert (p == debug_sections[DEBUG_MACRO].new_data
+		       + debug_sections[DEBUG_MACRO].new_size);
+	  htab_delete (macro_htab);
+	  macro_htab = NULL;
+	}
+      obstack_free (&ob, (void *) to_free);
+    }
+}
+
+/* Write new content of .debug_macro section during fi_multifile phase.  */
+static void
+write_macro (void)
+{
+  unsigned char *ptr, *endsec, *dst;
+  unsigned int op, strp;
+  struct macro_entry me, *m;
+
+  endsec = debug_sections[DEBUG_MACRO].data + debug_sections[DEBUG_MACRO].size;
+  debug_sections[DEBUG_MACRO].new_data
+    = (unsigned char *) malloc (debug_sections[DEBUG_MACRO].new_size);
+  if (debug_sections[DEBUG_MACRO].new_data == NULL)
+    dwz_oom ();
+  dst = debug_sections[DEBUG_MACRO].new_data;
+  for (ptr = debug_sections[DEBUG_MACRO].data; ptr < endsec; )
+    {
+      unsigned char *s = ptr;
+      unsigned char flags;
+
+      me.ptr = ptr;
+      m = (struct macro_entry *)
+	  htab_find_with_hash (macro_htab, &me,
+			       me.ptr - debug_sections[DEBUG_MACRO].data);
+      if (m->len)
+	{
+	  ptr += m->len;
+	  continue;
+	}
+
+      ptr += 2;
+      flags = read_8 (ptr);
+      if ((flags & 2) != 0)
+	ptr += 4;
+
+      while (1)
+	{
+	  op = read_8 (ptr);
+	  if (op == 0)
+	    break;
+
+	  switch (op)
+	    {
+	    case DW_MACRO_define:
+	    case DW_MACRO_undef:
+	      skip_leb128 (ptr);
+	      ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+	      break;
+	    case DW_MACRO_start_file:
+	      skip_leb128 (ptr);
+	      skip_leb128 (ptr);
+	      break;
+	    case DW_MACRO_end_file:
+	      break;
+	    case DW_MACRO_define_strp:
+	    case DW_MACRO_undef_strp:
+	      memcpy (dst, s, ptr - 1 - s);
+	      dst += ptr - 1 - s;
+	      s = ptr - 1;
+	      skip_leb128 (ptr);
+	      strp = read_32 (ptr);
+	      switch (note_strp_offset2 (strp))
+		{
+		case DW_FORM_GNU_strp_alt:
+		case DW_FORM_strp_sup:
+		  *dst = op == DW_MACRO_define_strp
+			 ? DW_MACRO_define_sup
+			 : DW_MACRO_undef_sup;
+		  dst++;
+		  s++;
+		  break;
+		default:
+		  break;
+		}
+	      memcpy (dst, s, ptr - 4 - s);
+	      dst += ptr - 4 - s;
+	      write_32 (dst, lookup_strp_offset (strp));
+	      s = ptr;
+	      break;
+	    case DW_MACRO_import:
+	      memcpy (dst, s, ptr - 1 - s);
+	      dst += ptr - 1 - s;
+	      me.ptr = debug_sections[DEBUG_MACRO].data + read_32 (ptr);
+	      m = (struct macro_entry *)
+		  htab_find_with_hash (macro_htab, &me,
+				       me.ptr
+				       - debug_sections[DEBUG_MACRO].data);
+	      if (m->len)
+		*dst = DW_MACRO_import_sup;
+	      else
+		*dst = DW_MACRO_import;
+	      dst++;
+	      write_32 (dst, m->hash);
+	      s = ptr;
+	      break;
+	    default:
+	      abort ();
+	    }
+	}
+      memcpy (dst, s, ptr - s);
+      dst += ptr - s;
+    }
+  assert (dst == debug_sections[DEBUG_MACRO].new_data
+		 + debug_sections[DEBUG_MACRO].new_size);
+}
+
+/* Compute new abbreviations for DIE (with reference DIE REF).
+   T is a temporary buffer.  Fill in *NDIES - number of DIEs
+   in the tree, and record pairs of referrer/referree DIEs for
+   intra-CU references into obstack vector VEC.  */
+static int
+build_abbrevs_for_die (htab_t h, dw_cu_ref cu, dw_die_ref die,
+		       dw_cu_ref refcu, dw_die_ref ref,
+		       struct abbrev_tag *t, unsigned int *ndies,
+		       struct obstack *vec, bool recompute)
+{
+  dw_die_ref child, ref_child, sib = NULL, origin = NULL;
+  unsigned int i, j;
+  uint64_t low_pc = 0;
+  void **slot;
+
+  if (unlikely (recompute) && die->u.p2.die_new_abbrev != NULL)
+    {
+      if (cu->cu_intracu_form == DW_FORM_ref_udata)
+	die->die_ref_seen = 1;
+      else
+	{
+	  die->die_size -= size_of_uleb128 (die->u.p2.die_new_abbrev->entry)
+			   + die->u.p2.die_intracu_udata_size;
+	  die->die_ref_seen = 0;
+	}
+      for (child = die->die_child; child; child = child->die_sib)
+	if (build_abbrevs_for_die (h, cu, child, NULL, NULL, t, ndies, vec,
+				   true))
+	  return 1;
+      return 0;
+    }
+
+  die->u.p2.die_new_abbrev = NULL;
+  die->u.p2.die_new_offset = 0;
+  die->u.p2.die_intracu_udata_size = 0;
+  die->die_ref_seen = 0;
+
+  if (wr_multifile ? die->die_no_multifile : die->die_remove)
+    return 0;
+  t->entry = 0;
+  t->tag = die->die_tag;
+  t->children = die->die_child != NULL;
+  t->op_type_referenced = false;
+  t->nusers = 1;
+  if (die->die_offset == -1U)
+    {
+      if (ref != NULL)
+	;
+      else if (die_safe_nextdup (die) && die->die_nextdup->die_dup == die)
+	{
+	  ref = die->die_nextdup;
+	  if (ref != NULL)
+	    refcu = die_cu (ref);
+	}
+      if (ref == NULL)
+	origin = die->die_nextdup;
+    }
+  else
+    {
+      ref = die;
+      refcu = cu;
+      if (wr_multifile
+	  && (die->die_root || die->die_named_namespace))
+	origin = die;
+    }
+  if (die->die_child && die->die_sib)
+    for (sib = die->die_sib; sib; sib = sib->die_sib)
+      if (wr_multifile ? !sib->die_no_multifile : !sib->die_remove)
+	break;
+  if (ref != NULL && origin == NULL)
+    {
+      unsigned char *base
+	= cu->cu_kind == CU_TYPES
+	  ? debug_sections[DEBUG_TYPES].data
+	  : debug_sections[DEBUG_INFO].data;
+      unsigned char *ptr = base + ref->die_offset;
+      struct abbrev_tag *reft = ref->die_abbrev;
+
+      skip_leb128 (ptr);
+      /* No longer count the abbrev uleb128 size in die_size.
+	 We'll add it back after determining the new abbrevs.  */
+      if (unlikely (wr_multifile || op_multifile || fi_multifile)
+	  || unlikely (recompute))
+	i = -1U;
+      else
+	for (i = 0; i < reft->nattr; i++)
+	  switch (reft->attr[i].form)
+	    {
+	    case DW_FORM_ref1:
+	    case DW_FORM_ref2:
+	    case DW_FORM_ref4:
+	    case DW_FORM_ref8:
+	    case DW_FORM_ref_udata:
+	    case DW_FORM_indirect:
+	      i = -2U;
+	      break;
+	    case DW_FORM_data4:
+	    case DW_FORM_data8:
+	      if (reft->attr[i].attr == DW_AT_high_pc)
+		i = -2U;
+	      break;
+	    case DW_FORM_addr:
+	      if (reft->attr[i].attr == DW_AT_high_pc
+		  && cu->cu_version >= 4)
+		i = -2U;
+	      break;
+	    default:
+	      break;
+	    }
+      if (i != -1U)
+	{
+	  die->die_size -= ptr - (base + ref->die_offset);
+	  /* If there are no references, size stays the same
+	     and no need to walk the actual attribute values.  */
+	  for (i = 0; i < reft->nattr; i++)
+	    {
+	      t->attr[i].attr = reft->attr[i].attr;
+	      t->attr[i].form = reft->attr[i].form;
+	      if (t->attr[i].form == DW_FORM_implicit_const)
+		t->values[i] = reft->values[i];
+	    }
+	  t->nattr = reft->nattr;
+	}
+      else
+	{
+	  die->die_size = 0;
+	  /* Otherwise, we need to walk the actual attributes.  */
+	  for (i = 0, j = 0; i < reft->nattr; ++i)
+	    {
+	      uint32_t form = reft->attr[i].form;
+	      size_t len = 0;
+	      dw_die_ref refd;
+	      uint64_t value = 0;
+	      unsigned char *orig_ptr = ptr;
+
+	      while (form == DW_FORM_indirect)
+		form = read_uleb128 (ptr);
+
+	      if (unlikely (wr_multifile || op_multifile)
+		  && (reft->attr[i].attr == DW_AT_decl_file
+		      || reft->attr[i].attr == DW_AT_call_file))
+		{
+		  switch (form)
+		    {
+		    case DW_FORM_data1: value = read_8 (ptr); break;
+		    case DW_FORM_data2: value = read_16 (ptr); break;
+		    case DW_FORM_data4: value = read_32 (ptr); break;
+		    case DW_FORM_data8: value = read_64 (ptr); break;
+		    case DW_FORM_udata: value = read_uleb128 (ptr); break;
+		    case DW_FORM_sdata: value = read_sleb128 (ptr); break;
+		    case DW_FORM_implicit_const:
+		      value = reft->values[i];
+		      break;
+		    default:
+		      error (0, 0, "Unhandled %s for %s",
+			     get_DW_FORM_str (form),
+			     get_DW_AT_str (reft->attr[i].attr));
+		      return 1;
+		    }
+		  value = line_htab_lookup (refcu, value);
+		  if (form != DW_FORM_implicit_const)
+		    {
+		      if (value <= 0xff)
+			{
+			  form = DW_FORM_data1;
+			  die->die_size++;
+			}
+		      else if (value <= 0xffff)
+			{
+			  form = DW_FORM_data2;
+			  die->die_size += 2;
+			}
+		      else if (value <= 0xffffffff)
+			{
+			  form = DW_FORM_data4;
+			  die->die_size += 4;
+			}
+		      else
+			{
+			  form = DW_FORM_data8;
+			  die->die_size += 8;
+			}
+		    }
+		  t->attr[j].attr = reft->attr[i].attr;
+		  t->attr[j].form = form;
+		  if (form == DW_FORM_implicit_const)
+		    t->values[j] = value;
+		  j++;
+		  continue;
+		}
+
+	      if (unlikely (fi_multifile)
+		  && (reft->attr[i].attr == DW_AT_GNU_macros
+		      || reft->attr[i].attr == DW_AT_macros)
+		  && alt_macro_htab != NULL)
+		{
+		  struct macro_entry me, *m;
+
+		  switch (form)
+		    {
+		    case DW_FORM_data4:
+		    case DW_FORM_sec_offset:
+		      value = read_32 (ptr);
+		      break;
+		    default:
+		      error (0, 0, "Unhandled %s for %s",
+			     get_DW_FORM_str (form),
+			     get_DW_AT_str (reft->attr[i].attr));
+		      return 1;
+		    }
+		  me.ptr = debug_sections[DEBUG_MACRO].data + value;
+		  m = (struct macro_entry *)
+		    htab_find_with_hash (macro_htab, &me, value);
+		  if (m->len)
+		    {
+		      error (0, 0, "%s referencing transparent include",
+			     get_DW_AT_str (reft->attr[i].attr));
+		      return 1;
+		    }
+		  ptr -= 4;
+		}
+
+	      switch (form)
+		{
+		case DW_FORM_ref_addr:
+		  if (unlikely (fi_multifile))
+		    {
+		      dw_die_ref refdt;
+		      value = read_size (ptr,
+					 refcu->cu_version == 2
+					 ? ptr_size : 4);
+		      ptr += refcu->cu_version == 2 ? ptr_size : 4;
+		      refd = off_htab_lookup (NULL, value);
+		      assert (refd != NULL);
+		      refdt = refd;
+		      while (refdt->die_toplevel == 0)
+			refdt = refdt->die_parent;
+		      if (refdt->die_dup
+			  && !refdt->die_op_type_referenced
+			  && die_cu (refdt->die_dup)->cu_kind == CU_ALT)
+			{
+			  t->attr[j].attr = reft->attr[i].attr;
+			  t->attr[j++].form
+			    = dwarf_5 ? DW_FORM_ref_sup4 : DW_FORM_GNU_ref_alt;
+			  die->die_size += 4;
+			  continue;
+			}
+		      break;
+		    }
+		  ptr += refcu->cu_version == 2 ? ptr_size : 4;
+		  break;
+		case DW_FORM_addr:
+		  ptr += ptr_size;
+		  if (reft->attr[i].attr == DW_AT_low_pc
+		      && cu->cu_version >= 4)
+		    low_pc = read_size (ptr - ptr_size, ptr_size);
+		  else if (reft->attr[i].attr == DW_AT_high_pc
+			   && low_pc)
+		    {
+		      uint64_t high_pc = read_size (ptr - ptr_size, ptr_size);
+		      /* If both DW_AT_low_pc and DW_AT_high_pc attributes
+			 are present and have DW_FORM_addr, attempt to shrink
+			 the DIE by using DW_FORM_udata or DW_FORM_data4
+			 form for the latter in DWARF4+.  Don't try
+			 DW_FORM_data[12], that might increase .debug_abbrev
+			 size too much or increase the uleb128 size of too
+			 many abbrev numbers.  */
+		      if (high_pc > low_pc)
+			{
+			  unsigned int nform = 0;
+			  unsigned int sz = size_of_uleb128 (high_pc - low_pc);
+			  if (sz <= 4 && sz <= (unsigned) ptr_size)
+			    nform = DW_FORM_udata;
+			  else if (ptr_size > 4
+				   && high_pc - low_pc <= 0xffffffff)
+			    {
+			      nform = DW_FORM_data4;
+			      sz = 4;
+			    }
+			  else if (sz <= (unsigned) ptr_size)
+			    nform = DW_FORM_udata;
+			  if (nform)
+			    {
+			      t->attr[j].attr = reft->attr[i].attr;
+			      t->attr[j++].form = nform;
+			      die->die_size += sz;
+			      continue;
+			    }
+			}
+		    }
+		  break;
+		case DW_FORM_flag_present:
+		case DW_FORM_implicit_const:
+		  break;
+		case DW_FORM_flag:
+		case DW_FORM_data1:
+		  ++ptr;
+		  break;
+		case DW_FORM_data2:
+		  ptr += 2;
+		  break;
+		case DW_FORM_data4:
+		  if (reft->attr[i].attr == DW_AT_high_pc)
+		    {
+		      uint32_t range_len = read_32 (ptr);
+		      unsigned int sz = size_of_uleb128 (range_len);
+		      if (sz <= 4)
+			{
+			  t->attr[j].attr = reft->attr[i].attr;
+			  t->attr[j++].form = DW_FORM_udata;
+			  die->die_size += sz;
+			  continue;
+			}
+		      break;
+		    }
+		  ptr += 4;
+		  break;
+		case DW_FORM_sec_offset:
+		  ptr += 4;
+		  break;
+		case DW_FORM_data8:
+		  if (reft->attr[i].attr == DW_AT_high_pc)
+		    {
+		      unsigned int nform = 0;
+		      uint64_t range_len = read_64 (ptr);
+		      unsigned int sz = size_of_uleb128 (range_len);
+		      if (sz <= 4)
+			nform = DW_FORM_udata;
+		      else if (range_len <= 0xffffffff)
+			{
+			  nform = DW_FORM_data4;
+			  sz = 4;
+			}
+		      else if (sz <= 8)
+			nform = DW_FORM_udata;
+		      if (nform)
+			{
+			  t->attr[j].attr = reft->attr[i].attr;
+			  t->attr[j++].form = nform;
+			  die->die_size += sz;
+			  continue;
+			}
+		      break;
+		    }
+		  ptr += 8;
+		  break;
+		case DW_FORM_ref_sig8:
+		  ptr += 8;
+		  break;
+		case DW_FORM_data16:
+		  ptr += 16;
+		  break;
+		case DW_FORM_sdata:
+		case DW_FORM_udata:
+		  skip_leb128 (ptr);
+		  break;
+		case DW_FORM_strp:
+		  if (unlikely (op_multifile || fi_multifile))
+		    {
+		      form = note_strp_offset2 (read_32 (ptr));
+		      if (form != DW_FORM_strp)
+			{
+			  t->attr[j].attr = reft->attr[i].attr;
+			  t->attr[j++].form = form;
+			  die->die_size += 4;
+			  continue;
+			}
+		    }
+		  else
+		    ptr += 4;
+		  break;
+		case DW_FORM_line_strp:
+		  /* Since we don't register the line_strp we cannot
+		     change the form in the case of multifile.  */
+		  ptr += 4;
+		  break;
+		case DW_FORM_string:
+		  ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+		  break;
+		case DW_FORM_indirect:
+		  abort ();
+		case DW_FORM_block1:
+		  len = *ptr++;
+		  break;
+		case DW_FORM_block2:
+		  len = read_16 (ptr);
+		  form = DW_FORM_block1;
+		  break;
+		case DW_FORM_block4:
+		  len = read_32 (ptr);
+		  form = DW_FORM_block1;
+		  break;
+		case DW_FORM_block:
+		case DW_FORM_exprloc:
+		  len = read_uleb128 (ptr);
+		  form = DW_FORM_block1;
+		  break;
+		case DW_FORM_ref1:
+		case DW_FORM_ref2:
+		case DW_FORM_ref4:
+		case DW_FORM_ref8:
+		case DW_FORM_ref_udata:
+		  switch (form)
+		    {
+		    case DW_FORM_ref1: value = read_8 (ptr); break;
+		    case DW_FORM_ref2: value = read_16 (ptr); break;
+		    case DW_FORM_ref4: value = read_32 (ptr); break;
+		    case DW_FORM_ref8: value = read_64 (ptr); break;
+		    case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+		    default: abort ();
+		    }
+		  if (reft->attr[i].attr == DW_AT_sibling)
+		    {
+		      if (sib == NULL)
+			continue;
+		      form = DW_FORM_ref4;
+		      refd = sib;
+		    }
+		  else
+		    {
+		      dw_die_ref refdt;
+		      refd = off_htab_lookup (refcu, refcu->cu_offset + value);
+		      assert (refd != NULL);
+		      refdt = refd;
+		      while (refdt->die_toplevel == 0)
+			refdt = refdt->die_parent;
+		      if (refdt->die_dup && refdt->die_op_type_referenced)
+			{
+			  if (cu == die_cu (refdt))
+			    form = DW_FORM_ref4;
+			  else if (cu == die_cu (refdt->die_dup))
+			    {
+			      form = DW_FORM_ref4;
+			      refd = die_find_dup (refdt, refdt->die_dup,
+						   refd);
+			    }
+			  else
+			    form = DW_FORM_ref_addr;
+			}
+		      else
+			{
+			  if (refdt->die_dup)
+			    refd = die_find_dup (refdt, refdt->die_dup, refd);
+			  if (cu == die_cu (refd))
+			    form = DW_FORM_ref4;
+			  else if (die_cu (refd)->cu_kind == CU_ALT)
+			    form = (dwarf_5
+				    ? DW_FORM_ref_sup4 : DW_FORM_GNU_ref_alt);
+			  else
+			    form = DW_FORM_ref_addr;
+			}
+		    }
+		  if (form == DW_FORM_ref_addr)
+		    die->die_size += cu->cu_version == 2 ? ptr_size : 4;
+		  else if (form == DW_FORM_GNU_ref_alt
+			   || form == DW_FORM_ref_sup4)
+		    die->die_size += 4;
+		  else
+		    {
+		      if (unlikely (recompute))
+			form = cu->cu_intracu_form;
+		      if (likely (!recompute) || form == DW_FORM_ref_udata)
+			{
+			  obstack_ptr_grow (vec, die);
+			  obstack_ptr_grow (vec, refd);
+			}
+		    }
+		  t->attr[j].attr = reft->attr[i].attr;
+		  t->attr[j++].form = form;
+		  continue;
+		default:
+		  abort ();
+		}
+
+	      if (form == DW_FORM_block1)
+		ptr += len;
+	      t->attr[j].attr = reft->attr[i].attr;
+	      t->attr[j].form = reft->attr[i].form;
+	      if (reft->attr[i].form == DW_FORM_implicit_const)
+		t->values[j] = reft->values[i];
+	      j++;
+	      die->die_size += ptr - orig_ptr;
+	    }
+	  t->nattr = j;
+	}
+    }
+  else
+    switch (die->die_tag)
+      {
+      case DW_TAG_partial_unit:
+      case DW_TAG_compile_unit:
+	t->nattr = 0;
+	die->die_size = 0;
+	if (origin == NULL)
+	  break;
+	refcu = die_cu (origin);
+	if (refcu->cu_nfiles)
+	  {
+	    t->attr[0].attr = DW_AT_stmt_list;
+	    t->attr[0].form = cu->cu_version < 4
+			      ? DW_FORM_data4 : DW_FORM_sec_offset;
+	    die->die_size += 4;
+	    t->nattr++;
+	  }
+	if (uni_lang_p || cu->cu_die->die_tag == DW_TAG_compile_unit)
+	  {
+	    unsigned int lang_size = nr_bytes_for (cu->lang);
+	    die->die_size += lang_size;
+	    t->attr[t->nattr].attr = DW_AT_language;
+	    switch (lang_size)
+	      {
+	      case 1:
+		t->attr[t->nattr].form = DW_FORM_data1;
+		break;
+	      case 2:
+		t->attr[t->nattr].form = DW_FORM_data2;
+		break;
+	      default:
+		abort ();
+	      }
+	    t->nattr++;
+	  }
+	if (refcu->cu_comp_dir)
+	  {
+	    enum dwarf_form form;
+	    unsigned char *ptr = get_AT (origin, DW_AT_comp_dir, &form);
+	    assert (ptr && (form == DW_FORM_string
+			    || form == DW_FORM_strp
+			    || form == DW_FORM_line_strp));
+	    if (form == DW_FORM_strp)
+	      {
+		if (unlikely (op_multifile || fi_multifile))
+		  form = note_strp_offset2 (read_32 (ptr));
+		die->die_size += 4;
+	      }
+	    else if (form == DW_FORM_line_strp)
+	      die->die_size += 4;
+	    else
+	      die->die_size
+		+= strlen (refcu->cu_comp_dir) + 1;
+	    t->attr[t->nattr].attr = DW_AT_comp_dir;
+	    t->attr[t->nattr].form = form;
+	    t->nattr++;
+	  }
+	break;
+      case DW_TAG_namespace:
+      case DW_TAG_module:
+	{
+	  enum dwarf_form form;
+	  unsigned char *ptr = get_AT (origin, DW_AT_name, &form);
+	  assert (ptr && (form == DW_FORM_string
+			  || form == DW_FORM_strp
+			  || form == DW_FORM_line_strp));
+	  if (form == DW_FORM_strp)
+	    {
+	      if (unlikely (op_multifile || fi_multifile))
+		form = note_strp_offset2 (read_32 (ptr));
+	      die->die_size = 4;
+	    }
+	  else if (form == DW_FORM_line_strp)
+	    die->die_size += 4;
+	  else
+	    die->die_size = strlen ((char *) ptr) + 1;
+	  t->attr[0].attr = DW_AT_name;
+	  t->attr[0].form = form;
+	  t->nattr = 1;
+	  if (sib)
+	    {
+	      t->attr[1].attr = DW_AT_sibling;
+	      t->attr[1].form = DW_FORM_ref4;
+	      obstack_ptr_grow (vec, die);
+	      obstack_ptr_grow (vec, sib);
+	      t->nattr++;
+	    }
+	  break;
+	}
+      case DW_TAG_imported_unit:
+	t->attr[0].attr = DW_AT_import;
+	t->nattr = 1;
+	if (die_cu (die->die_nextdup)->cu_kind == CU_ALT)
+	  {
+	    t->attr[0].form = dwarf_5 ? DW_FORM_ref_sup4 : DW_FORM_GNU_ref_alt;
+	    die->die_size = 4;
+	  }
+	else
+	  {
+	    t->attr[0].form = DW_FORM_ref_addr;
+	    die->die_size = cu->cu_version == 2 ? ptr_size : 4;
+	  }
+	break;
+      default:
+	abort ();
+      }
+  compute_abbrev_hash (t);
+  slot = htab_find_slot_with_hash (h, t, t->hash,
+				   recompute ? NO_INSERT : INSERT);
+  if (slot == NULL)
+    dwz_oom ();
+  if (unlikely (recompute))
+    assert (*slot);
+  if (*slot)
+    {
+      if (likely (!recompute))
+	((struct abbrev_tag *)*slot)->nusers++;
+      die->u.p2.die_new_abbrev = (struct abbrev_tag *)*slot;
+    }
+  else
+    {
+      struct abbrev_tag *newt = pool_clone_abbrev (t);
+      *slot = newt;
+      die->u.p2.die_new_abbrev = newt;
+    }
+  (*ndies)++;
+  if (ref != NULL && ref != die)
+    {
+      for (child = die->die_child, ref_child = ref->die_child;
+	   child; child = child->die_sib, ref_child = ref_child->die_sib)
+	if (build_abbrevs_for_die (h, cu, child, refcu, ref_child,
+				   t, ndies, vec, recompute))
+	  return 1;
+    }
+  else
+    for (child = die->die_child; child; child = child->die_sib)
+      if (build_abbrevs_for_die (h, cu, child, NULL, NULL, t, ndies, vec,
+				 recompute))
+	return 1;
+  return 0;
+}
+
+/* Build new abbreviations for CU.  T, NDIES and VEC arguments like
+   for build_abbrevs_for_die.  */
+static int
+build_abbrevs (dw_cu_ref cu, struct abbrev_tag *t, unsigned int *ndies,
+	       struct obstack *vec)
+{
+  htab_t h = htab_try_create (50, abbrev_hash, abbrev_eq2, NULL);
+
+  if (h == NULL)
+    dwz_oom ();
+
+  if (build_abbrevs_for_die (h, cu, cu->cu_die, NULL, NULL, t, ndies, vec,
+			     false))
+    {
+      htab_delete (h);
+      return 1;
+    }
+
+  cu->cu_new_abbrev = h;
+  return 0;
+}
+
+/* Helper to record all abbrevs from the hash table into ob obstack
+   vector.  Called through htab_traverse.  */
+static int
+list_abbrevs (void **slot, void *data)
+{
+  struct obstack *obp = (struct obstack *) data;
+  obstack_ptr_grow (obp, *slot);
+  return 1;
+}
+
+/* Comparison function for abbreviations.  Used for CUs that
+   need 128 or more abbreviations.  Use lowest numbers (i.e. sort earlier)
+   abbrevs used for typed DWARF stack referenced DIEs, then sort
+   by decreasing number of users (abbrev numbers are uleb128 encoded,
+   the bigger number of them that can be 1 byte encoded the better).  */
+static int
+abbrev_cmp (const void *p, const void *q)
+{
+  struct abbrev_tag *t1 = *(struct abbrev_tag **)p;
+  struct abbrev_tag *t2 = *(struct abbrev_tag **)q;
+  unsigned int i;
+
+  if (t1->op_type_referenced && !t2->op_type_referenced)
+    return -1;
+  if (!t1->op_type_referenced && t2->op_type_referenced)
+    return 1;
+  if (t1->nusers > t2->nusers)
+    return -1;
+  if (t1->nusers < t2->nusers)
+    return 1;
+  /* The rest just so that we have a stable sort.  */
+  if (t1->tag < t2->tag)
+    return -1;
+  if (t1->tag > t2->tag)
+    return 1;
+  if (t1->nattr < t2->nattr)
+    return -1;
+  if (t1->nattr > t2->nattr)
+    return 1;
+  if (t1->children && !t2->children)
+    return -1;
+  if (!t1->children && t2->children)
+    return 1;
+  for (i = 0; i < t1->nattr; i++)
+    {
+      if (t1->attr[i].attr < t2->attr[i].attr)
+	return -1;
+      if (t1->attr[i].attr > t2->attr[i].attr)
+	return 1;
+      if (t1->attr[i].form < t2->attr[i].form)
+	return -1;
+      if (t1->attr[i].form > t2->attr[i].form)
+	return 1;
+      if (t1->attr[i].form == DW_FORM_implicit_const)
+	{
+	  if (t1->values[i] < t2->values[i])
+	    return -1;
+	  if (t1->values[i] > t2->values[i])
+	    return 1;
+	}
+    }
+  return 0;
+}
+
+/* First phase of computation of u.p2.die_new_offset and
+   new CU sizes.  */
+static unsigned int
+init_new_die_offsets (dw_die_ref die, unsigned int off,
+		      unsigned int intracusize)
+{
+  dw_die_ref child;
+  unsigned int i;
+  struct abbrev_tag *t = die->u.p2.die_new_abbrev;
+  if (wr_multifile ? die->die_no_multifile : die->die_remove)
+    return off;
+  die->u.p2.die_new_offset = off;
+  if (likely (die->die_ref_seen == 0))
+    {
+      die->die_size += size_of_uleb128 (die->u.p2.die_new_abbrev->entry);
+      die->u.p2.die_intracu_udata_size = 0;
+      for (i = 0; i < t->nattr; ++i)
+	switch (t->attr[i].form)
+	  {
+	  case DW_FORM_ref1:
+	  case DW_FORM_ref2:
+	  case DW_FORM_ref4:
+	  case DW_FORM_ref_udata:
+	    die->u.p2.die_intracu_udata_size += intracusize;
+	    break;
+	  default:
+	    break;
+	  }
+      die->die_size += die->u.p2.die_intracu_udata_size;
+    }
+  off += die->die_size;
+  for (child = die->die_child; child; child = child->die_sib)
+    off = init_new_die_offsets (child, off, intracusize);
+  if (die->die_child)
+    off++;
+  return off;
+}
+
+/* Second phase of computation of u.p2.die_new_offset and
+   new CU sizes.  This step is called possibly many times,
+   for deciding if DW_FORM_ref_udata is worthwhile.
+   init_new_die_offsets starts with assuming each uleb128 will
+   need maximum number of bytes for the CU of the given size,
+   each new invocation of this function (except the last)
+   will shrink one or more uleb128s.  Each shrinking can create
+   new opportunities to shrink other uleb128s.  */
+static unsigned int
+update_new_die_offsets (dw_die_ref die, unsigned int off,
+			dw_die_ref **intracuvec)
+{
+  dw_die_ref child;
+  if (wr_multifile ? die->die_no_multifile : die->die_remove)
+    return off;
+  assert (off <= die->u.p2.die_new_offset);
+  die->u.p2.die_new_offset = off;
+  if ((*intracuvec)[0] == die)
+    {
+      unsigned int intracu_udata_size = 0;
+      assert (die->u.p2.die_intracu_udata_size);
+      while ((*intracuvec)[0] == die)
+	{
+	  intracu_udata_size
+	    += size_of_uleb128 ((*intracuvec)[1]->u.p2.die_new_offset);
+	  *intracuvec += 2;
+	}
+      assert (die->u.p2.die_intracu_udata_size >= intracu_udata_size);
+      die->die_size -= die->u.p2.die_intracu_udata_size - intracu_udata_size;
+      die->u.p2.die_intracu_udata_size = intracu_udata_size;
+    }
+  else
+    assert (die->u.p2.die_intracu_udata_size == 0 || die->die_ref_seen);
+  off += die->die_size;
+  for (child = die->die_child; child; child = child->die_sib)
+    off = update_new_die_offsets (child, off, intracuvec);
+  if (die->die_child)
+    off++;
+  return off;
+}
+
+/* Final phase of computation of u.p2.die_new_offset.  Called when already
+   decided what intra-CU form will be used.  Can return -1U if
+   a problem is detected and the tool should give up.  */
+static unsigned int
+finalize_new_die_offsets (dw_cu_ref cu, dw_die_ref die, unsigned int off,
+			  unsigned int intracusize, dw_die_ref **intracuvec)
+{
+  dw_die_ref child;
+  unsigned int ref_seen = die->die_ref_seen;
+  if (wr_multifile ? die->die_no_multifile : die->die_remove)
+    return off;
+  die->u.p2.die_new_offset = off;
+  die->die_ref_seen = 0;
+  /* As we aren't adjusting sizes of exprloc, if in the new layout
+     a DIE referenced through DW_OP_call2 is placed after 64K into
+     the CU, punt.  */
+  if (die->die_op_call2_referenced && off >= 65536)
+    return -1U;
+  /* Similarly punt if
+     DW_OP_GNU_{{regval,const,deref}_type,convert,reinterpret}
+     references a DIE that needs more uleb128 bytes to encode
+     the new offset compared to uleb128 bytes to encode the old offset.
+     GCC emits DW_TAG_base_type dies referenced that way at the
+     beginning of the CU and we try to preserve that, so this shouldn't
+     trigger for GCC generated code.  */
+  if (die->die_op_type_referenced
+      && !wr_multifile
+      && size_of_uleb128 (off)
+	 > size_of_uleb128 (die->die_offset - cu->cu_offset))
+    return -1U;
+  if ((*intracuvec)[0] == die)
+    {
+      unsigned int intracu_udata_size = 0;
+      assert (die->u.p2.die_intracu_udata_size);
+      while ((*intracuvec)[0] == die)
+	{
+	  intracu_udata_size += intracusize;
+	  *intracuvec += 2;
+	}
+      if (intracusize != 0)
+	{
+	  die->die_size
+	    -= die->u.p2.die_intracu_udata_size - intracu_udata_size;
+	  die->u.p2.die_intracu_udata_size = intracu_udata_size;
+	}
+    }
+  else
+    assert (die->u.p2.die_intracu_udata_size == 0 || ref_seen);
+  off += die->die_size;
+  for (child = die->die_child; child; child = child->die_sib)
+    {
+      off = finalize_new_die_offsets (cu, child, off, intracusize, intracuvec);
+      if (off == -1U)
+	return off;
+    }
+  if (die->die_child)
+    off++;
+  return off;
+}
+
+/* Comparison function, called through qsort, to sort CUs
+   by increasing number of needed new abbreviations.  */
+static int
+cu_abbrev_cmp (const void *p, const void *q)
+{
+  dw_cu_ref cu1 = *(dw_cu_ref *)p;
+  dw_cu_ref cu2 = *(dw_cu_ref *)q;
+  unsigned int nabbrevs1 = htab_elements (cu1->cu_new_abbrev);
+  unsigned int nabbrevs2 = htab_elements (cu2->cu_new_abbrev);
+
+  if (nabbrevs1 < nabbrevs2)
+    return -1;
+  if (nabbrevs1 > nabbrevs2)
+    return 1;
+  /* The rest is just to get stable sort.  */
+  if (cu1->cu_kind != CU_PU && cu2->cu_kind == CU_PU)
+    return -1;
+  if (cu1->cu_kind == CU_PU && cu2->cu_kind != CU_PU)
+    return 1;
+  if (cu1->cu_offset < cu2->cu_offset)
+    return -1;
+  if (cu1->cu_offset > cu2->cu_offset)
+    return 1;
+  return 0;
+}
+
+/* Compute new abbreviations for all CUs, size the new
+   .debug_abbrev section and all new .debug_info CUs.  */
+static int
+compute_abbrevs (DSO *dso)
+{
+  unsigned long total_size = 0, types_size = 0, abbrev_size = 0;
+  dw_cu_ref cu, *cuarr;
+  struct abbrev_tag *t;
+  unsigned int ncus, nlargeabbrevs = 0, i, laststart;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "compute_abbrevs\n");
+    }
+
+  t = (struct abbrev_tag *)
+      obstack_alloc (&ob2,
+		     sizeof (*t)
+		     + (max_nattr + 4) * sizeof (struct abbrev_attr)
+		     + (max_nattr + 4) * sizeof (int64_t));
+  t->values = (int64_t *) &t->attr[max_nattr + 4];
+  for (cu = first_cu, ncus = 0; cu; cu = cu->cu_next)
+    {
+      unsigned int intracu, ndies = 0, tagsize = 0, nchildren = 0;
+      unsigned int nabbrevs, diesize, cusize, off, intracusize;
+      struct abbrev_tag **arr;
+      dw_die_ref *intracuarr, *intracuvec;
+      enum dwarf_form intracuform = DW_FORM_ref4;
+      dw_die_ref child, *lastotr, child_next, *last;
+      unsigned int headersz = (cu->cu_kind == CU_TYPES
+			       ? 23 : (cu->cu_version >= 5 ? 12 : 11));
+
+      if (unlikely (fi_multifile) && cu->cu_die->die_remove)
+	continue;
+      if (unlikely (low_mem) && cu->cu_kind != CU_PU)
+	expand_children (cu->cu_die);
+      ncus++;
+      if (build_abbrevs (cu, t, &ndies, &ob2))
+	return 1;
+      nabbrevs = htab_elements (cu->cu_new_abbrev);
+      htab_traverse (cu->cu_new_abbrev, list_abbrevs, &ob);
+      assert (obstack_object_size (&ob) == nabbrevs * sizeof (void *));
+      arr = (struct abbrev_tag **) obstack_finish (&ob);
+      intracu = obstack_object_size (&ob2) / sizeof (void *) / 2;
+      obstack_ptr_grow (&ob2, NULL);
+      intracuarr = (dw_die_ref *) obstack_finish (&ob2);
+      if (nabbrevs >= 128)
+	{
+	  unsigned int limit, uleb128_size;
+
+	  for (child = cu->cu_die->die_child; child; child = child->die_sib)
+	    if (child->die_op_type_referenced && !wr_multifile)
+	      {
+		child->u.p2.die_new_abbrev->op_type_referenced = 1;
+		/* If the old offset was close to uleb128 boundary, ensure
+		   that DW_TAG_compile_unit gets small abbrev number
+		   as well.  */
+		if (size_of_uleb128 (child->die_offset - cu->cu_offset)
+		    < size_of_uleb128 (child->die_offset - cu->cu_offset + 1))
+		  cu->cu_die->u.p2.die_new_abbrev->op_type_referenced = 1;
+	      }
+	  qsort (arr, nabbrevs, sizeof (*arr), abbrev_cmp);
+	  for (i = 0, limit = 128, uleb128_size = 1; i < nabbrevs; i++)
+	    {
+	      if (i + 1 == limit)
+		{
+		  limit <<= 7;
+		  uleb128_size++;
+		}
+	      arr[i]->entry = i + 1;
+	      tagsize += arr[i]->nusers * uleb128_size;
+	      if (arr[i]->children)
+		nchildren += arr[i]->nusers;
+	    }
+	  nlargeabbrevs++;
+	}
+      else
+	{
+	  tagsize = ndies;
+	  for (i = 0; i < nabbrevs; i++)
+	    {
+	      arr[i]->entry = i + 1;
+	      if (arr[i]->children)
+		nchildren += arr[i]->nusers;
+	    }
+	}
+
+      /* Move all base types with die_op_type_reference
+	 to front, to increase the likelyhood that the offset
+	 will fit.  */
+      for (last = &cu->cu_die->die_child, lastotr = last, child = *last;
+	   child; child = child_next)
+	{
+	  child_next = child->die_sib;
+	  if (child->die_op_type_referenced)
+	    {
+	      if (lastotr != last)
+		{
+		  child->die_sib = *lastotr;
+		  *lastotr = child;
+		  lastotr = &child->die_sib;
+		  *last = child_next;
+		  continue;
+		}
+	      lastotr = &child->die_sib;
+	    }
+	  last = &child->die_sib;
+	}
+
+      cu->u2.cu_largest_entry = nabbrevs;
+      diesize = calc_sizes (cu->cu_die);
+      cusize = headersz + tagsize + diesize + nchildren;
+      intracusize = size_of_uleb128 (cusize + intracu);
+      do
+	{
+	  i = size_of_uleb128 (cusize + intracu * intracusize);
+	  if (i == intracusize)
+	    break;
+	  intracusize = i;
+	}
+      while (1);
+      cu->initial_intracusize = intracusize;
+      off = init_new_die_offsets (cu->cu_die, headersz, intracusize);
+      do
+	{
+	  intracuvec = intracuarr;
+	  i = update_new_die_offsets (cu->cu_die, headersz, &intracuvec);
+	  assert (*intracuvec == NULL);
+	  if (i == off)
+	    break;
+	  assert (i < off);
+	  off = i;
+	}
+      while (1);
+      if (cusize + intracu <= 256)
+	{
+	  intracuform = DW_FORM_ref1;
+	  intracusize = 1;
+	  cusize += intracu;
+	}
+      else if (cusize + intracu * 2 <= 65536)
+	{
+	  intracuform = DW_FORM_ref2;
+	  intracusize = 2;
+	  cusize += intracu * 2;
+	}
+      else
+	{
+	  cusize += intracu * 4;
+	  intracusize = 4;
+	}
+      if (off <= cusize)
+	{
+	  intracuform = DW_FORM_ref_udata;
+	  intracusize = 0;
+	  cusize = off;
+	}
+
+      intracuvec = intracuarr;
+      off = finalize_new_die_offsets (cu, cu->cu_die, headersz, intracusize,
+				      &intracuvec);
+      if (off == -1U)
+	{
+	  error (0, 0, "%s: DW_OP_call2 or typed DWARF stack referenced DIE"
+		       " layed out at too big offset", dso->filename);
+	  return 1;
+	}
+      assert (*intracuvec == NULL && off == cusize);
+      cu->cu_intracu_form = intracuform;
+
+      if (intracuform != DW_FORM_ref4)
+	{
+	  unsigned int j;
+	  htab_empty (cu->cu_new_abbrev);
+	  for (i = 0; i < nabbrevs; i++)
+	    {
+	      void **slot;
+	      for (j = 0; j < arr[i]->nattr; j++)
+		if (arr[i]->attr[j].form == DW_FORM_ref4)
+		  arr[i]->attr[j].form = intracuform;
+	      compute_abbrev_hash (arr[i]);
+	      slot = htab_find_slot_with_hash (cu->cu_new_abbrev, arr[i],
+					       arr[i]->hash, INSERT);
+	      if (slot == NULL)
+		dwz_oom ();
+	      assert (slot != NULL && *slot == NULL);
+	      *slot = arr[i];
+	    }
+	}
+      obstack_free (&ob, (void *) arr);
+      obstack_free (&ob2, (void *) intracuarr);
+      if (cu->cu_kind == CU_TYPES)
+	{
+	  cu->cu_new_offset = types_size;
+	  types_size += cusize;
+	}
+      else
+	{
+	  cu->cu_new_offset = (wr_multifile ? multi_info_off : 0) + total_size;
+	  total_size += cusize;
+	}
+
+      if (unlikely (low_mem) && cu->cu_kind != CU_PU)
+	collapse_children (cu, cu->cu_die);
+    }
+  if (wr_multifile)
+    total_size += 11; /* See the end of write_info.  */
+  obstack_free (&ob2, (void *) t);
+  cuarr = (dw_cu_ref *) obstack_alloc (&ob2, ncus * sizeof (dw_cu_ref));
+  for (cu = first_cu, i = 0; cu; cu = cu->cu_next)
+    if (cu->u1.cu_new_abbrev_owner == NULL
+	&& (likely (!fi_multifile)
+	    || cu->cu_kind != CU_NORMAL
+	    || !cu->cu_die->die_remove))
+      cuarr[i++] = cu;
+  assert (i == ncus);
+  qsort (cuarr, ncus, sizeof (dw_cu_ref), cu_abbrev_cmp);
+  /* For CUs with < 128 abbrevs, try to see if either all of the
+     abbrevs are at < 128 positions in >= 128 abbrev CUs, or
+     can be merged with some other small abbrev table to form
+     a < 128 abbrev table.  */
+  laststart = ncus - nlargeabbrevs;
+  for (i = ncus - 1; i != -1U; i--)
+    {
+      struct abbrev_tag **arr;
+      unsigned int nabbrevs, j, k, nattempts;
+
+      if (cuarr[i]->u1.cu_new_abbrev_owner != NULL)
+	continue;
+      nabbrevs = htab_elements (cuarr[i]->cu_new_abbrev);
+      htab_traverse (cuarr[i]->cu_new_abbrev, list_abbrevs, &ob2);
+      assert (obstack_object_size (&ob2) == nabbrevs * sizeof (void *));
+      arr = (struct abbrev_tag **) obstack_finish (&ob2);
+      if (nabbrevs >= 128)
+	{
+	  nattempts = 0;
+	  for (j = i + 1; j < ncus; j++)
+	    {
+	      unsigned int entry;
+	      if (cuarr[j]->u1.cu_new_abbrev_owner)
+		continue;
+	      if (++nattempts == 100)
+		break;
+	      entry = cuarr[j]->u2.cu_largest_entry;
+	      for (k = 0; k < nabbrevs; k++)
+		{
+		  struct abbrev_tag *t
+		    = htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+					   arr[k], arr[k]->hash);
+		  if (t == NULL)
+		    {
+		      ++entry;
+		      if (size_of_uleb128 (entry)
+			  != size_of_uleb128 (arr[k]->entry))
+			break;
+		    }
+		  else if (size_of_uleb128 (t->entry)
+			   != size_of_uleb128 (arr[k]->entry))
+		    break;
+		}
+	      if (k != nabbrevs)
+		continue;
+	      entry = cuarr[j]->u2.cu_largest_entry;
+	      for (k = 0; k < nabbrevs; k++)
+		{
+		  void **slot
+		    = htab_find_slot_with_hash (cuarr[j]->cu_new_abbrev,
+						arr[k], arr[k]->hash,
+						INSERT);
+		  if (slot == NULL)
+		    dwz_oom ();
+		  if (*slot != NULL)
+		    arr[k]->entry = ((struct abbrev_tag *) *slot)->entry;
+		  else
+		    {
+		      struct abbrev_tag *newt;
+		      arr[k]->entry = ++entry;
+		      newt = pool_clone_abbrev (arr[k]);
+		      *slot = newt;
+		    }
+		}
+	      cuarr[j]->u2.cu_largest_entry = entry;
+	      cuarr[i]->u1.cu_new_abbrev_owner = cuarr[j];
+	      break;
+	    }
+	  obstack_free (&ob2, (void *) arr);
+	  continue;
+	}
+      /* Don't search all CUs, that might be too expensive.  So just search
+	 100 of >= 128 abbrev tables, if there are more than 100, different
+	 set each time.  We are looking for a full match (i.e. that
+	 cuarr[i] abbrevs are a subset of cuarr[j] abbrevs, and all of them
+	 are in the low positions.  */
+      for (j = laststart, nattempts = -1U; nlargeabbrevs; j++)
+	{
+	  if (j == ncus)
+	    j -= nlargeabbrevs;
+	  if (nattempts != -1U && j == laststart)
+	    break;
+	  if (nattempts == -1U)
+	    nattempts = 0;
+	  if (cuarr[j]->u1.cu_new_abbrev_owner)
+	    continue;
+	  if (++nattempts == 100)
+	    break;
+	  for (k = 0; k < nabbrevs; k++)
+	    {
+	      struct abbrev_tag *t
+		= htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+				       arr[k], arr[k]->hash);
+	      if (t == NULL || t->entry >= 128)
+		break;
+	    }
+	  if (k == nabbrevs)
+	    {
+	      for (k = 0; k < nabbrevs; k++)
+		{
+		  struct abbrev_tag *t
+		    = htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+					   arr[k], arr[k]->hash);
+		  arr[k]->entry = t->entry;
+		}
+	      cuarr[i]->u1.cu_new_abbrev_owner = cuarr[j];
+	      break;
+	    }
+	}
+      if (nlargeabbrevs > 100)
+	laststart = j;
+      if (cuarr[i]->u1.cu_new_abbrev_owner == NULL)
+	{
+	  unsigned int maxdups = 0, maxdupidx = 0;
+	  /* Next search up to 100 of small abbrev CUs, looking
+	     for best match.  */
+	  nattempts = 0;
+	  for (j = i + 1; j < ncus - nlargeabbrevs; j++)
+	    {
+	      unsigned int curdups = 0;
+	      if (cuarr[j]->u1.cu_new_abbrev_owner)
+		continue;
+	      if (++nattempts == 100)
+		break;
+	      for (k = 0; k < nabbrevs; k++)
+		{
+		  struct abbrev_tag *t
+		    = htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+					   arr[k], arr[k]->hash);
+		  if (t != NULL)
+		    curdups++;
+		}
+	      if (curdups > maxdups
+		  && cuarr[j]->u2.cu_largest_entry - curdups + nabbrevs < 128)
+		{
+		  maxdups = curdups;
+		  maxdupidx = j;
+		  if (maxdups == nabbrevs)
+		    break;
+		}
+	    }
+	  if (maxdups)
+	    {
+	      unsigned int entry = cuarr[maxdupidx]->u2.cu_largest_entry;
+	      j = maxdupidx;
+	      for (k = 0; k < nabbrevs; k++)
+		{
+		  void **slot
+		    = htab_find_slot_with_hash (cuarr[j]->cu_new_abbrev,
+						arr[k], arr[k]->hash,
+						INSERT);
+		  if (slot == NULL)
+		    dwz_oom ();
+		  if (*slot != NULL)
+		    arr[k]->entry = ((struct abbrev_tag *) *slot)->entry;
+		  else
+		    {
+		      struct abbrev_tag *newt;
+		      arr[k]->entry = ++entry;
+		      newt = pool_clone_abbrev (arr[k]);
+		      *slot = newt;
+		    }
+		}
+	      cuarr[j]->u2.cu_largest_entry = entry;
+	      cuarr[i]->u1.cu_new_abbrev_owner = cuarr[j];
+	    }
+	}
+      obstack_free (&ob2, (void *) arr);
+    }
+  obstack_free (&ob2, (void *) t);
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    {
+      struct abbrev_tag **arr;
+      unsigned int nabbrevs, j;
+
+      if (unlikely (fi_multifile)
+	  && cu->cu_kind == CU_NORMAL
+	  && cu->cu_die->die_remove)
+	continue;
+      if (cu->u1.cu_new_abbrev_owner != NULL)
+	{
+	  cu->u2.cu_new_abbrev_offset = -1U;
+	  if (cu->cu_new_abbrev)
+	    htab_delete (cu->cu_new_abbrev);
+	  cu->cu_new_abbrev = NULL;
+	  continue;
+	}
+      cu->u2.cu_new_abbrev_offset
+	= (wr_multifile ? multi_abbrev_off : 0) + abbrev_size;
+      nabbrevs = htab_elements (cu->cu_new_abbrev);
+      htab_traverse (cu->cu_new_abbrev, list_abbrevs, &ob);
+      assert (obstack_object_size (&ob) == nabbrevs * sizeof (void *));
+      arr = (struct abbrev_tag **) obstack_finish (&ob);
+      for (i = 0; i < nabbrevs; i++)
+	{
+	  abbrev_size += size_of_uleb128 (arr[i]->entry);
+	  abbrev_size += size_of_uleb128 (arr[i]->tag);
+	  abbrev_size += 1;
+	  for (j = 0; j < arr[i]->nattr; j++)
+	    {
+	      abbrev_size += size_of_uleb128 (arr[i]->attr[j].attr);
+	      abbrev_size += size_of_uleb128 (arr[i]->attr[j].form);
+	      if (arr[i]->attr[j].form == DW_FORM_implicit_const)
+		abbrev_size += size_of_sleb128 (arr[i]->values[j]);
+	    }
+	  abbrev_size += 2;
+	}
+      abbrev_size += 1;
+      obstack_free (&ob, (void *) arr);
+    }
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    if (unlikely (fi_multifile)
+	  && cu->cu_kind == CU_NORMAL
+	  && cu->cu_die->die_remove)
+      continue;
+    else if (cu->u2.cu_new_abbrev_offset == -1U)
+      {
+	dw_cu_ref owner = cu;
+	unsigned int cu_new_abbrev_offset;
+	while (owner->u1.cu_new_abbrev_owner != NULL)
+	  owner = owner->u1.cu_new_abbrev_owner;
+	cu_new_abbrev_offset = owner->u2.cu_new_abbrev_offset;
+	owner = cu;
+	while (owner->u1.cu_new_abbrev_owner != NULL)
+	  {
+	    owner->u2.cu_new_abbrev_offset = cu_new_abbrev_offset;
+	    owner = owner->u1.cu_new_abbrev_owner;
+	  }
+      }
+  debug_sections[DEBUG_INFO].new_size = total_size;
+  debug_sections[DEBUG_ABBREV].new_size = abbrev_size;
+  debug_sections[DEBUG_TYPES].new_size = types_size;
+  return 0;
+}
+
+/* Comparison function, sort abbreviations by increasing
+   entry value.  */
+static int
+abbrev_entry_cmp (const void *p, const void *q)
+{
+  struct abbrev_tag *t1 = *(struct abbrev_tag **)p;
+  struct abbrev_tag *t2 = *(struct abbrev_tag **)q;
+
+  if (t1->entry < t2->entry)
+    return -1;
+  if (t1->entry > t2->entry)
+    return 1;
+  return 0;
+}
+
+/* Construct the new .debug_abbrev section
+   in malloced memory, store it as debug_sections[DEBUG_ABBREV].new_data.  */
+static void
+write_abbrev (void)
+{
+  dw_cu_ref cu;
+  unsigned char *abbrev = malloc (debug_sections[DEBUG_ABBREV].new_size);
+  unsigned char *ptr = abbrev;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "write_abbrev\n");
+    }
+
+  if (abbrev == NULL)
+    dwz_oom ();
+
+  debug_sections[DEBUG_ABBREV].new_data = abbrev;
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    {
+      struct abbrev_tag **arr;
+      unsigned int nabbrevs, i, j;
+
+      if (unlikely (fi_multifile)
+	  && cu->cu_kind == CU_NORMAL
+	  && cu->cu_die->die_remove)
+	continue;
+      if (cu->u1.cu_new_abbrev_owner != NULL)
+	continue;
+      nabbrevs = htab_elements (cu->cu_new_abbrev);
+      htab_traverse (cu->cu_new_abbrev, list_abbrevs, &ob);
+      assert (obstack_object_size (&ob) == nabbrevs * sizeof (void *));
+      arr = (struct abbrev_tag **) obstack_finish (&ob);
+      qsort (arr, nabbrevs, sizeof (*arr), abbrev_entry_cmp);
+      for (i = 0; i < nabbrevs; i++)
+	{
+	  write_uleb128 (ptr, arr[i]->entry);
+	  write_uleb128 (ptr, arr[i]->tag);
+	  *ptr++ = arr[i]->children ? DW_CHILDREN_yes : DW_CHILDREN_no;
+	  for (j = 0; j < arr[i]->nattr; j++)
+	    {
+	      write_uleb128 (ptr, arr[i]->attr[j].attr);
+	      write_uleb128 (ptr, arr[i]->attr[j].form);
+	      if (arr[i]->attr[j].form == DW_FORM_implicit_const)
+		write_sleb128 (ptr, arr[i]->values[j]);
+	    }
+	  *ptr++ = 0;
+	  *ptr++ = 0;
+	}
+      *ptr++ = 0;
+      obstack_free (&ob, (void *) arr);
+      if (likely (!low_mem))
+	{
+	  htab_delete (cu->cu_new_abbrev);
+	  cu->cu_new_abbrev = NULL;
+	}
+    }
+  assert (abbrev + debug_sections[DEBUG_ABBREV].new_size == ptr);
+}
+
+/* Adjust DWARF expression starting at PTR, LEN bytes long, referenced by
+   DIE, with REF being the original DIE.  */
+static void
+adjust_exprloc (dw_cu_ref cu, dw_die_ref die, dw_cu_ref refcu,
+		dw_die_ref ref, unsigned char *ptr, size_t len)
+{
+  unsigned char *end = ptr + len, *orig_ptr = NULL;
+  unsigned char op;
+  uint32_t leni;
+  GElf_Addr addr;
+  dw_die_ref refd, refdt;
+
+  while (ptr < end)
+    {
+      op = *ptr++;
+      switch (op)
+	{
+	case DW_OP_addr:
+	  ptr += ptr_size;
+	  break;
+	case DW_OP_deref:
+	case DW_OP_dup:
+	case DW_OP_drop:
+	case DW_OP_over:
+	case DW_OP_swap:
+	case DW_OP_rot:
+	case DW_OP_xderef:
+	case DW_OP_abs:
+	case DW_OP_and:
+	case DW_OP_div:
+	case DW_OP_minus:
+	case DW_OP_mod:
+	case DW_OP_mul:
+	case DW_OP_neg:
+	case DW_OP_not:
+	case DW_OP_or:
+	case DW_OP_plus:
+	case DW_OP_shl:
+	case DW_OP_shr:
+	case DW_OP_shra:
+	case DW_OP_xor:
+	case DW_OP_eq:
+	case DW_OP_ge:
+	case DW_OP_gt:
+	case DW_OP_le:
+	case DW_OP_lt:
+	case DW_OP_ne:
+	case DW_OP_lit0 ... DW_OP_lit31:
+	case DW_OP_reg0 ... DW_OP_reg31:
+	case DW_OP_nop:
+	case DW_OP_push_object_address:
+	case DW_OP_form_tls_address:
+	case DW_OP_call_frame_cfa:
+	case DW_OP_stack_value:
+	case DW_OP_GNU_push_tls_address:
+	case DW_OP_GNU_uninit:
+	  break;
+	case DW_OP_const1u:
+	case DW_OP_pick:
+	case DW_OP_deref_size:
+	case DW_OP_xderef_size:
+	case DW_OP_const1s:
+	  ++ptr;
+	  break;
+	case DW_OP_const2u:
+	case DW_OP_const2s:
+	case DW_OP_skip:
+	case DW_OP_bra:
+	  ptr += 2;
+	  break;
+	case DW_OP_call2:
+	case DW_OP_call4:
+	case DW_OP_GNU_parameter_ref:
+	  if (op == DW_OP_call2)
+	    addr = read_16 (ptr);
+	  else
+	    addr = read_32 (ptr);
+	  refd = off_htab_lookup (refcu, refcu->cu_offset + addr);
+	  assert (refd != NULL && !refd->die_remove);
+	  if (op == DW_OP_call2)
+	    {
+	      assert (refd->u.p2.die_new_offset <= 65535);
+	      ptr -= 2;
+	      write_16 (ptr, refd->u.p2.die_new_offset);
+	    }
+	  else
+	    {
+	      ptr -= 4;
+	      write_32 (ptr, refd->u.p2.die_new_offset);
+	    }
+	  break;
+	case DW_OP_const4u:
+	case DW_OP_const4s:
+	  ptr += 4;
+	  break;
+	case DW_OP_call_ref:
+	case DW_OP_GNU_implicit_pointer:
+	case DW_OP_implicit_pointer:
+	case DW_OP_GNU_variable_value:
+	  addr = read_size (ptr, refcu->cu_version == 2 ? ptr_size : 4);
+	  assert (cu->cu_version == refcu->cu_version);
+	  refd = off_htab_lookup (NULL, addr);
+	  assert (refd != NULL);
+	  refdt = refd;
+	  while (refdt->die_toplevel == 0)
+	    refdt = refdt->die_parent;
+	  if (refdt->die_dup && !refdt->die_op_type_referenced)
+	    refd = die_find_dup (refdt, refdt->die_dup, refd);
+	  write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+		      die_cu (refd)->cu_new_offset
+		      + refd->u.p2.die_new_offset);
+	  if (cu->cu_version == 2)
+	    ptr += ptr_size;
+	  else
+	    ptr += 4;
+	  if (op == DW_OP_GNU_implicit_pointer || op == DW_OP_implicit_pointer)
+	    skip_leb128 (ptr);
+	  break;
+	case DW_OP_const8u:
+	case DW_OP_const8s:
+	  ptr += 8;
+	  break;
+	case DW_OP_constu:
+	case DW_OP_plus_uconst:
+	case DW_OP_regx:
+	case DW_OP_piece:
+	case DW_OP_consts:
+	case DW_OP_breg0 ... DW_OP_breg31:
+	case DW_OP_fbreg:
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_bregx:
+	case DW_OP_bit_piece:
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  break;
+	case DW_OP_implicit_value:
+	  leni = read_uleb128 (ptr);
+	  ptr += leni;
+	  break;
+	case DW_OP_GNU_entry_value:
+	case DW_OP_entry_value:
+	  leni = read_uleb128 (ptr);
+	  assert ((uint64_t) (end - ptr) >= leni);
+	  adjust_exprloc (cu, die, refcu, ref, ptr, leni);
+	  ptr += leni;
+	  break;
+	case DW_OP_GNU_convert:
+	case DW_OP_convert:
+	case DW_OP_GNU_reinterpret:
+	case DW_OP_reinterpret:
+	  orig_ptr = ptr;
+	  addr = read_uleb128 (ptr);
+	  if (addr == 0)
+	    break;
+	  goto typed_dwarf;
+	case DW_OP_GNU_regval_type:
+	case DW_OP_regval_type:
+	  skip_leb128 (ptr);
+	  orig_ptr = ptr;
+	  addr = read_uleb128 (ptr);
+	  goto typed_dwarf;
+	case DW_OP_GNU_const_type:
+	case DW_OP_const_type:
+	  orig_ptr = ptr;
+	  addr = read_uleb128 (ptr);
+	  goto typed_dwarf;
+	case DW_OP_GNU_deref_type:
+	case DW_OP_deref_type:
+	  ++ptr;
+	  orig_ptr = ptr;
+	  addr = read_uleb128 (ptr);
+	typed_dwarf:
+	  refd = off_htab_lookup (refcu, refcu->cu_offset + addr);
+	  assert (refd != NULL && refd->die_op_type_referenced);
+	  leni = ptr - orig_ptr;
+	  assert (size_of_uleb128 (refd->u.p2.die_new_offset) <= leni);
+	  ptr = orig_ptr;
+	  write_uleb128 (ptr, refd->u.p2.die_new_offset);
+	  /* If the new offset ends up being shorter uleb128
+	     encoded than the old, pad it up to make it still valid,
+	     but not shortest, uleb128.  Changing sizes of
+	     exprloc would be a nightmare.  Another alternative would
+	     be to pad with DW_OP_nop after the op.  */
+	  if (ptr < orig_ptr + leni)
+	    {
+	      ptr[-1] |= 0x80;
+	      while (ptr < orig_ptr + leni - 1)
+		*ptr++ = 0x80;
+	      *ptr++ = 0;
+	    }
+	  if (op == DW_OP_GNU_const_type || op == DW_OP_const_type)
+	    ptr += *ptr + 1;
+	  break;
+	default:
+	  abort ();
+	}
+    }
+}
+
+/* Write DW_TAG_unit_* DIE (with ORIGIN being the corresponding original DIE) to
+   memory starting at PTR, return pointer after the DIE.  */
+static unsigned char *
+write_unit_die (unsigned char *ptr, dw_die_ref die, dw_die_ref origin)
+{
+  struct abbrev_tag *t = die->u.p2.die_new_abbrev;
+  unsigned int i;
+
+  for (i = 0; i < t->nattr; ++i)
+    {
+      struct abbrev_attr *attr = &t->attr[i];
+      switch (attr->attr)
+	{
+	case DW_AT_stmt_list:
+	  {
+	    enum dwarf_form form;
+	    unsigned char *p = get_AT (origin, DW_AT_stmt_list, &form);
+	    assert (p && (form == DW_FORM_sec_offset
+			  || form == DW_FORM_data4));
+	    if (wr_multifile)
+	      write_32 (ptr, multi_line_off);
+	    else if (op_multifile)
+	      write_32 (ptr, 0);
+	    else
+	      {
+		memcpy (ptr, p, 4);
+		ptr += 4;
+	      }
+	  }
+	  break;
+	case DW_AT_comp_dir:
+	  {
+	    enum dwarf_form form;
+	    unsigned char *p = get_AT (origin, DW_AT_comp_dir, &form);
+	    assert (p);
+	    assert (form == attr->form
+		    || (form == DW_FORM_strp
+			&& (attr->form == DW_FORM_GNU_strp_alt
+			    || attr->form == DW_FORM_strp_sup)));
+	    if (form == DW_FORM_strp)
+	      {
+		if (unlikely (wr_multifile || op_multifile || fi_multifile))
+		  {
+		    unsigned int strp = lookup_strp_offset (read_32 (p));
+		    write_32 (ptr, strp);
+		  }
+		else
+		  {
+		    memcpy (ptr, p, 4);
+		    ptr += 4;
+		  }
+	      }
+	    else if (form == DW_FORM_line_strp)
+	      {
+		memcpy (ptr, p, 4);
+		ptr += 4;
+	      }
+	    else
+	      {
+		size_t len = strlen ((char *) p) + 1;
+		memcpy (ptr, p, len);
+		ptr += len;
+	      }
+	  }
+	  break;
+	case DW_AT_language:
+	  {
+	    enum dwarf_source_language lang = die_cu (die)->lang;
+	    unsigned int lang_size = nr_bytes_for (lang);
+	    write_size (ptr, lang_size, lang);
+	    ptr += lang_size;
+	  }
+	  break;
+	default:
+	  assert (false);
+	  break;
+	}
+    }
+
+  return ptr;
+}
+
+/* Write DIE (with REF being the corresponding original DIE) to
+   memory starting at PTR, return pointer after the DIE.  */
+static unsigned char *
+write_die (unsigned char *ptr, dw_cu_ref cu, dw_die_ref die,
+	   dw_cu_ref refcu, dw_die_ref ref, unsigned int *die_count)
+{
+  uint64_t low_pc = 0;
+  dw_die_ref child, sib = NULL, origin = NULL;
+  struct abbrev_tag *t;
+
+  if (wr_multifile ? die->die_no_multifile : die->die_remove)
+    return ptr;
+  if (die_count)
+    (*die_count)++;
+  if (die->die_offset == -1U)
+    {
+      if (ref != NULL)
+	;
+      else if (die_safe_nextdup (die) && die->die_nextdup->die_dup == die)
+	{
+	  ref = die->die_nextdup;
+	  refcu = die_cu (ref);
+	}
+      if (ref == NULL)
+	origin = die->die_nextdup;
+    }
+  else
+    {
+      ref = die;
+      refcu = cu;
+      if (wr_multifile
+	  && (die->die_root || die->die_named_namespace))
+	origin = die;
+    }
+  if (die->die_child && die->die_sib)
+    for (sib = die->die_sib; sib; sib = sib->die_sib)
+      if (wr_multifile ? !sib->die_no_multifile : !sib->die_remove)
+	break;
+  t = die->u.p2.die_new_abbrev;
+  write_uleb128 (ptr, t->entry);
+  if (ref != NULL && origin == NULL)
+    {
+      unsigned char *base
+	= cu->cu_kind == CU_TYPES
+	  ? debug_sections[DEBUG_TYPES].data
+	  : debug_sections[DEBUG_INFO].data;
+      unsigned char *inptr = base + ref->die_offset;
+      struct abbrev_tag *reft = ref->die_abbrev;
+      unsigned int i, j;
+
+      skip_leb128 (inptr);
+      for (i = 0, j = 0; i < reft->nattr; ++i)
+	{
+	  uint32_t form = reft->attr[i].form;
+	  size_t len = 0;
+	  uint64_t value;
+	  unsigned char *orig_ptr = inptr;
+
+	  while (form == DW_FORM_indirect)
+	    form = read_uleb128 (inptr);
+
+	  if (unlikely (wr_multifile || op_multifile)
+	      && (reft->attr[i].attr == DW_AT_decl_file
+		  || reft->attr[i].attr == DW_AT_call_file))
+	    {
+	      switch (form)
+		{
+		case DW_FORM_data1:
+		  value = read_8 (inptr);
+		  break;
+		case DW_FORM_data2:
+		  value = read_16 (inptr);
+		  break;
+		case DW_FORM_data4:
+		  value = read_32 (inptr);
+		  break;
+		case DW_FORM_data8:
+		  value = read_64 (inptr);
+		  break;
+		case DW_FORM_udata:
+		  value = read_uleb128 (inptr);
+		  break;
+		case DW_FORM_sdata:
+		  value = read_sleb128 (inptr);
+		  break;
+		case DW_FORM_implicit_const:
+		  /* DW_FORM_implicit_const should have been updated
+		     already when computing abbrevs.  */
+		  j++;
+		  continue;
+		default: abort ();
+		}
+	      value = line_htab_lookup (refcu, value);
+	      switch (t->attr[j].form)
+		{
+		  case DW_FORM_data1: write_8 (ptr, value); break;
+		  case DW_FORM_data2: write_16 (ptr, value); break;
+		  case DW_FORM_data4: write_32 (ptr, value); break;
+		  case DW_FORM_data8: write_64 (ptr, value); break;
+		  case DW_FORM_udata: write_uleb128 (ptr, value); break;
+		  case DW_FORM_sdata: write_sleb128 (ptr, value); break;
+		  default: abort ();
+		}
+	      j++;
+	      continue;
+	    }
+
+	  if (unlikely (fi_multifile)
+	      && (reft->attr[i].attr == DW_AT_GNU_macros
+		  || reft->attr[i].attr == DW_AT_macros)
+	      && alt_macro_htab != NULL)
+	    {
+	      struct macro_entry me, *m;
+
+	      memcpy (ptr, orig_ptr, inptr - orig_ptr);
+	      ptr += inptr - orig_ptr;
+	      value = read_32 (inptr);
+	      me.ptr = debug_sections[DEBUG_MACRO].data + value;
+	      m = (struct macro_entry *)
+		  htab_find_with_hash (macro_htab, &me, value);
+	      write_32 (ptr, m->hash);
+	      j++;
+	      continue;
+	    }
+
+	  switch (form)
+	    {
+	    case DW_FORM_ref_addr:
+	      {
+		dw_die_ref refd, refdt;
+		if (t->attr[j].form != DW_FORM_GNU_ref_alt
+		    && t->attr[j].form != DW_FORM_ref_sup4)
+		  {
+		    memcpy (ptr, orig_ptr, inptr - orig_ptr);
+		    ptr += inptr - orig_ptr;
+		  }
+		value = read_size (inptr, refcu->cu_version == 2
+					  ? ptr_size : 4);
+		inptr += refcu->cu_version == 2 ? ptr_size : 4;
+		refd = off_htab_lookup (NULL, value);
+		if (refd == NULL || refd->die_tag == 0)
+		  error (1, 0, "Couldn't find DIE at DW_FORM_ref_addr offset"
+			 " 0x%" PRIx64, value);
+		assert (refd != NULL);
+		refdt = refd;
+		while (refdt->die_toplevel == 0)
+		  refdt = refdt->die_parent;
+		if (refdt->die_dup && !refdt->die_op_type_referenced)
+		  {
+		    refd = die_find_dup (refdt, refdt->die_dup, refd);
+		    if (t->attr[j].form == DW_FORM_GNU_ref_alt
+			|| t->attr[j].form == DW_FORM_ref_sup4)
+		      {
+			assert (die_cu (refd)->cu_kind == CU_ALT);
+			write_32 (ptr, refd->die_offset);
+			j++;
+			continue;
+		      }
+		  }
+		assert (refd->u.p2.die_new_offset
+			&& t->attr[j].form != DW_FORM_GNU_ref_alt
+			&& t->attr[j].form != DW_FORM_ref_sup4);
+		value = die_cu (refd)->cu_new_offset
+			+ refd->u.p2.die_new_offset;
+		write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+			    value);
+		ptr += cu->cu_version == 2 ? ptr_size : 4;
+		if (unlikely (op_multifile))
+		  assert (die_cu (refd)->cu_kind == CU_PU);
+		j++;
+		continue;
+	      }
+	    case DW_FORM_addr:
+	      inptr += ptr_size;
+	      if (reft->attr[i].attr == DW_AT_low_pc)
+		low_pc = read_size (inptr - ptr_size, ptr_size);
+	      if (reft->attr[i].attr == DW_AT_high_pc
+		  && t->attr[j].form != reft->attr[i].form)
+		{
+		  uint64_t high_pc = read_size (inptr - ptr_size, ptr_size);
+		  switch (t->attr[j].form)
+		    {
+		    case DW_FORM_udata:
+		      write_uleb128 (ptr, high_pc - low_pc);
+		      break;
+		    case DW_FORM_data4:
+		      write_32 (ptr, high_pc - low_pc);
+		      break;
+		    default:
+		      abort ();
+		    }
+		  j++;
+		  continue;
+		}
+	      break;
+	    case DW_FORM_flag_present:
+	    case DW_FORM_implicit_const:
+	      break;
+	    case DW_FORM_flag:
+	    case DW_FORM_data1:
+	      ++inptr;
+	      break;
+	    case DW_FORM_data2:
+	      inptr += 2;
+	      break;
+	    case DW_FORM_data4:
+	      if (reft->attr[i].attr == DW_AT_high_pc
+		  && t->attr[j].form != reft->attr[i].form)
+		{
+		  uint32_t range_len = read_32 (inptr);
+		  switch (t->attr[j].form)
+		    {
+		    case DW_FORM_udata:
+		      write_uleb128 (ptr, range_len);
+		      break;
+		    default:
+		      abort ();
+		    }
+		  j++;
+		  continue;
+		}
+	      inptr += 4;
+	      break;
+	    case DW_FORM_sec_offset:
+	      inptr += 4;
+	      break;
+	    case DW_FORM_data8:
+	      if (reft->attr[i].attr == DW_AT_high_pc
+		  && t->attr[j].form != reft->attr[i].form)
+		{
+		  uint64_t range_len = read_64 (inptr);
+		  switch (t->attr[j].form)
+		    {
+		    case DW_FORM_udata:
+		      write_uleb128 (ptr, range_len);
+		      break;
+		    case DW_FORM_data4:
+		      write_32 (ptr, range_len);
+		      break;
+		    default:
+		      abort ();
+		    }
+		  j++;
+		  continue;
+		}
+	      inptr += 8;
+	      break;
+	    case DW_FORM_ref_sig8:
+	      inptr += 8;
+	      break;
+	    case DW_FORM_data16:
+	      inptr += 16;
+	      break;
+	    case DW_FORM_sdata:
+	    case DW_FORM_udata:
+	      skip_leb128 (inptr);
+	      break;
+	    case DW_FORM_strp:
+	      if (unlikely (wr_multifile || op_multifile || fi_multifile))
+		{
+		  unsigned int strp = lookup_strp_offset (read_32 (inptr));
+		  memcpy (ptr, orig_ptr, inptr - 4 - orig_ptr);
+		  ptr += inptr - 4 - orig_ptr;
+		  write_32 (ptr, strp);
+		  j++;
+		  continue;
+		}
+	      inptr += 4;
+	      break;
+	    case DW_FORM_line_strp:
+	      inptr += 4;
+	      break;
+	    case DW_FORM_string:
+	      inptr = (unsigned char *) strchr ((char *)inptr, '\0') + 1;
+	      break;
+	    case DW_FORM_indirect:
+	      abort ();
+	    case DW_FORM_block1:
+	      len = *inptr++;
+	      break;
+	    case DW_FORM_block2:
+	      len = read_16 (inptr);
+	      form = DW_FORM_block1;
+	      break;
+	    case DW_FORM_block4:
+	      len = read_32 (inptr);
+	      form = DW_FORM_block1;
+	      break;
+	    case DW_FORM_block:
+	      len = read_uleb128 (inptr);
+	      form = DW_FORM_block1;
+	      break;
+	    case DW_FORM_exprloc:
+	      len = read_uleb128 (inptr);
+	      break;
+	    case DW_FORM_ref1:
+	    case DW_FORM_ref2:
+	    case DW_FORM_ref4:
+	    case DW_FORM_ref8:
+	    case DW_FORM_ref_udata:
+	      switch (form)
+		{
+		case DW_FORM_ref1: value = read_8 (inptr); break;
+		case DW_FORM_ref2: value = read_16 (inptr); break;
+		case DW_FORM_ref4: value = read_32 (inptr); break;
+		case DW_FORM_ref8: value = read_64 (inptr); break;
+		case DW_FORM_ref_udata: value = read_uleb128 (inptr); break;
+		default: abort ();
+		}
+	      if (reft->attr[i].attr == DW_AT_sibling)
+		{
+		  if (j == t->nattr
+		      || t->attr[j].attr != DW_AT_sibling)
+		    continue;
+		  assert (sib);
+		  value = sib->u.p2.die_new_offset;
+		}
+	      else
+		{
+		  dw_die_ref refdt, refd
+		    = off_htab_lookup (refcu, refcu->cu_offset + value);
+		  assert (refd != NULL);
+		  refdt = refd;
+		  while (refdt->die_toplevel == 0)
+		    refdt = refdt->die_parent;
+		  if (refdt->die_dup && refdt->die_op_type_referenced
+		      && cu->cu_kind != CU_PU)
+		    {
+		      if (cu == die_cu (refdt->die_dup))
+			refd = die_find_dup (refdt, refdt->die_dup, refd);
+		    }
+		  else if (refdt->die_dup)
+		    refd = die_find_dup (refdt, refdt->die_dup, refd);
+		  if (t->attr[j].form == DW_FORM_GNU_ref_alt
+		      || t->attr[j].form == DW_FORM_ref_sup4)
+		    {
+		      value = refd->die_offset;
+		      assert (die_cu (refd)->cu_kind == CU_ALT);
+		    }
+		  else
+		    {
+		      dw_cu_ref refdcu = die_cu (refd);
+		      value = refd->u.p2.die_new_offset;
+		      assert (IMPLIES (cu->cu_kind == CU_PU,
+				       die_cu (refd)->cu_kind == CU_PU));
+		      assert (value && refdcu->cu_kind != CU_ALT);
+		      if (t->attr[j].form == DW_FORM_ref_addr)
+			{
+			  value += refdcu->cu_new_offset;
+			  if (unlikely (op_multifile))
+			    assert (refdcu->cu_kind == CU_PU);
+			}
+		      else
+			assert (refdcu == cu);
+		    }
+		}
+	      switch (t->attr[j].form)
+		{
+		case DW_FORM_ref1: write_8 (ptr, value); break;
+		case DW_FORM_ref2: write_16 (ptr, value); break;
+		case DW_FORM_ref4: write_32 (ptr, value); break;
+		case DW_FORM_ref_udata: write_uleb128 (ptr, value); break;
+		case DW_FORM_ref_addr:
+		  write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+			      value);
+		  ptr += cu->cu_version == 2 ? ptr_size : 4;
+		  break;
+		case DW_FORM_GNU_ref_alt:
+		case DW_FORM_ref_sup4:
+		  write_32 (ptr, value);
+		  break;
+		case DW_FORM_ref_sup8:
+		  write_64 (ptr, value);
+		  break;
+		default:
+		  abort ();
+		}
+	      j++;
+	      continue;
+	    default:
+	      abort ();
+	    }
+
+	  if (form == DW_FORM_block1 || form == DW_FORM_exprloc)
+	    inptr += len;
+
+	  memcpy (ptr, orig_ptr, inptr - orig_ptr);
+	  ptr += inptr - orig_ptr;
+
+	  /* Old DWARF uses blocks instead of exprlocs.  */
+	  if (form == DW_FORM_block1 && cu->cu_version < 4)
+	    switch (reft->attr[i].attr)
+	      {
+	      case DW_AT_frame_base:
+	      case DW_AT_location:
+	      case DW_AT_data_member_location:
+	      case DW_AT_vtable_elem_location:
+	      case DW_AT_byte_size:
+	      case DW_AT_bit_offset:
+	      case DW_AT_bit_size:
+	      case DW_AT_string_length:
+	      case DW_AT_lower_bound:
+	      case DW_AT_return_addr:
+	      case DW_AT_bit_stride:
+	      case DW_AT_upper_bound:
+	      case DW_AT_count:
+	      case DW_AT_segment:
+	      case DW_AT_static_link:
+	      case DW_AT_use_location:
+	      case DW_AT_allocated:
+	      case DW_AT_associated:
+	      case DW_AT_data_location:
+	      case DW_AT_byte_stride:
+	      case DW_AT_rank:
+	      case DW_AT_call_value:
+	      case DW_AT_call_target:
+	      case DW_AT_call_target_clobbered:
+	      case DW_AT_call_data_location:
+	      case DW_AT_call_data_value:
+	      case DW_AT_GNU_call_site_value:
+	      case DW_AT_GNU_call_site_data_value:
+	      case DW_AT_GNU_call_site_target:
+	      case DW_AT_GNU_call_site_target_clobbered:
+		adjust_exprloc (cu, die, refcu, ref, ptr - len, len);
+	      default:
+		break;
+	      }
+	  else if (form == DW_FORM_exprloc)
+	    adjust_exprloc (cu, die, refcu, ref, ptr - len, len);
+	  j++;
+	}
+      assert (j == t->nattr);
+    }
+  else
+    switch (die->die_tag)
+      {
+      case DW_TAG_partial_unit:
+      case DW_TAG_compile_unit:
+	ptr = write_unit_die (ptr, die, origin);
+	break;
+      case DW_TAG_namespace:
+      case DW_TAG_module:
+	{
+	  enum dwarf_form form;
+	  unsigned char *p = get_AT (origin, DW_AT_name, &form);
+	  assert (p && (form == t->attr[0].form
+			|| (form == DW_FORM_strp
+			    && (t->attr[0].form == DW_FORM_GNU_strp_alt
+				|| t->attr[0].form == DW_FORM_strp_sup))));
+	  if (form == DW_FORM_strp)
+	    {
+	      if (unlikely (wr_multifile || op_multifile || fi_multifile))
+		{
+		  unsigned int strp = lookup_strp_offset (read_32 (p));
+		  write_32 (ptr, strp);
+		}
+	      else
+		{
+		  memcpy (ptr, p, 4);
+		  ptr += 4;
+		}
+	    }
+	  else if (form == DW_FORM_line_strp)
+	    {
+	      memcpy (ptr, p, 4);
+	      ptr += 4;
+	    }
+	  else
+	    {
+	      size_t len = strlen ((char *) p) + 1;
+	      memcpy (ptr, p, len);
+	      ptr += len;
+	    }
+	  if (t->nattr > 1)
+	    {
+	      assert (sib);
+	      switch (t->attr[1].form)
+		{
+		case DW_FORM_ref1:
+		  write_8 (ptr, sib->u.p2.die_new_offset);
+		  break;
+		case DW_FORM_ref2:
+		  write_16 (ptr, sib->u.p2.die_new_offset);
+		  break;
+		case DW_FORM_ref4:
+		  write_32 (ptr, sib->u.p2.die_new_offset);
+		  break;
+		case DW_FORM_ref_udata:
+		  write_uleb128 (ptr, sib->u.p2.die_new_offset);
+		  break;
+		default:
+		  abort ();
+		}
+	    }
+	  break;
+	}
+      case DW_TAG_imported_unit:
+	refcu = die_cu (origin);
+	if (t->attr[0].form == DW_FORM_GNU_ref_alt
+	    || t->attr[0].form == DW_FORM_ref_sup4)
+	  {
+	    assert (refcu->cu_kind == CU_ALT);
+	    write_32 (ptr, origin->die_offset);
+	    break;
+	  }
+	assert (refcu->cu_kind != CU_ALT);
+	write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+		    refcu->cu_new_offset
+		    + origin->u.p2.die_new_offset);
+	ptr += cu->cu_version == 2 ? ptr_size : 4;
+	break;
+      default:
+	abort ();
+      }
+  if (ref != NULL && ref != die)
+    {
+      dw_die_ref ref_child;
+      for (child = die->die_child, ref_child = ref->die_child;
+	   child; child = child->die_sib, ref_child = ref_child->die_sib)
+	ptr = write_die (ptr, cu, child, refcu, ref_child, die_count);
+    }
+  else
+    for (child = die->die_child; child; child = child->die_sib)
+      ptr = write_die (ptr, cu, child, NULL, NULL, die_count);
+  if (die->die_child)
+    write_8 (ptr, 0);
+  return ptr;
+}
+
+/* Recompute abbrevs for CU.  If any children were collapsed during
+   compute_abbrevs, their ->u.p2.die_new_abbrev and ->u.p2.die_new_offset
+   fields are no longer available and need to be computed again.  */
+static void
+recompute_abbrevs (dw_cu_ref cu, unsigned int cu_size)
+{
+  unsigned int headersz = (cu->cu_kind == CU_TYPES
+			   ? 23 : (cu->cu_version >= 5 ? 12 : 11));
+  struct abbrev_tag *t;
+  unsigned int ndies = 0, intracusize, off, i;
+  dw_die_ref *intracuarr, *intracuvec;
+
+  t = (struct abbrev_tag *)
+      obstack_alloc (&ob2,
+		     sizeof (*t)
+		     + (max_nattr + 4) * sizeof (struct abbrev_attr)
+		     + (max_nattr + 4) * sizeof (int64_t));
+  t->values = (int64_t *) &t->attr[max_nattr + 4];
+
+  build_abbrevs_for_die (cu->u1.cu_new_abbrev_owner
+			 ? cu->u1.cu_new_abbrev_owner->cu_new_abbrev
+			 : cu->cu_new_abbrev, cu, cu->cu_die, NULL, NULL, t,
+			 &ndies, &ob2, true);
+
+  obstack_ptr_grow (&ob2, NULL);
+  intracuarr = (dw_die_ref *) obstack_finish (&ob2);
+  if (cu->cu_intracu_form != DW_FORM_ref_udata)
+    {
+      switch (cu->cu_intracu_form)
+	{
+	case DW_FORM_ref1: intracusize = 1; break;
+	case DW_FORM_ref2: intracusize = 2; break;
+	case DW_FORM_ref4: intracusize = 4; break;
+	default: abort ();
+	}
+      off = init_new_die_offsets (cu->cu_die, headersz, intracusize);
+    }
+  else
+    {
+      intracusize = cu->initial_intracusize;
+
+      off = init_new_die_offsets (cu->cu_die, headersz, intracusize);
+      do
+	{
+	  intracuvec = intracuarr;
+	  i = update_new_die_offsets (cu->cu_die, headersz, &intracuvec);
+	  assert (*intracuvec == NULL);
+	  if (i == off)
+	    break;
+	  assert (i < off);
+	  off = i;
+	}
+      while (1);
+
+      intracuvec = intracuarr;
+      off = finalize_new_die_offsets (cu, cu->cu_die, headersz, 0,
+				      &intracuvec);
+      assert (*intracuvec == NULL);
+    }
+  obstack_free (&ob2, (void *) t);
+  assert (off == cu_size);
+}
+
+/* Construct new .debug_info section in malloced memory,
+   store it to debug_sections[DEBUG_INFO].new_data.  */
+static void
+write_info (unsigned int *die_count)
+{
+  dw_cu_ref cu, cu_next;
+  unsigned char *info = malloc (debug_sections[DEBUG_INFO].new_size);
+  unsigned char *ptr = info;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "write_info\n");
+    }
+
+  if (info == NULL)
+    dwz_oom ();
+  if (die_count)
+    *die_count = 0;
+  debug_sections[DEBUG_INFO].new_data = info;
+  cu = first_cu;
+  if (unlikely (fi_multifile))
+    while (cu
+	   && cu->cu_kind == CU_NORMAL
+	   && cu->cu_die->die_remove)
+      cu = cu->cu_next;
+  for (; cu; cu = cu_next)
+    {
+      unsigned long next_off = debug_sections[DEBUG_INFO].new_size;
+      /* Ignore .debug_types CUs.  */
+      if (cu->cu_kind == CU_TYPES)
+	break;
+      cu_next = cu->cu_next;
+      if (unlikely (fi_multifile))
+	while (cu_next
+	       && cu_next->cu_kind == CU_NORMAL
+	       && cu_next->cu_die->die_remove)
+	  cu_next = cu_next->cu_next;
+      if (cu_next && cu_next->cu_kind == CU_TYPES)
+	cu_next = NULL;
+      if (cu_next)
+	next_off = cu_next->cu_new_offset;
+      else if (wr_multifile)
+	next_off += multi_info_off - 11L;
+      if (unlikely (low_mem)
+	  && cu->cu_kind != CU_PU
+	  && expand_children (cu->cu_die))
+	recompute_abbrevs (cu, next_off - cu->cu_new_offset);
+      /* Write CU header.  */
+      write_32 (ptr, next_off - cu->cu_new_offset - 4);
+      write_16 (ptr, cu->cu_version);
+      if (cu->cu_version >= 5)
+	{
+	  *ptr++ = (cu->cu_die->die_tag == DW_TAG_compile_unit
+		    ? DW_UT_compile : DW_UT_partial);
+	  write_8 (ptr, ptr_size);
+	}
+      write_32 (ptr, cu->u2.cu_new_abbrev_offset);
+      if (cu->cu_version < 5)
+	write_8 (ptr, ptr_size);
+      ptr = write_die (ptr, cu, cu->cu_die, NULL, NULL, die_count);
+      assert (info + (next_off - (wr_multifile ? multi_info_off : 0)) == ptr);
+      if (unlikely (low_mem) && cu->cu_kind != CU_PU)
+	collapse_children (cu, cu->cu_die);
+    }
+  if (wr_multifile)
+    {
+      /* And terminate the contribution by the current object file.  */
+      write_32 (ptr, 7);
+      write_16 (ptr, 2);
+      write_32 (ptr, 0);
+      write_8 (ptr, ptr_size);
+    }
+  assert (info + debug_sections[DEBUG_INFO].new_size == ptr);
+}
+
+/* Adjust .debug_loc range determined by *SLOT, called through
+   htab_traverse.  */
+static int
+adjust_loclist (void **slot, void *data)
+{
+  struct debug_loc_adjust *adj = (struct debug_loc_adjust *) *slot;
+  unsigned char *ptr, *endsec;
+  GElf_Addr low, high;
+  size_t len;
+
+  (void)data;
+
+  ptr = debug_sections[DEBUG_LOC].new_data + adj->start_offset;
+  endsec = ptr + debug_sections[DEBUG_LOC].size;
+  while (ptr < endsec)
+    {
+      low = read_size (ptr, ptr_size);
+      high = read_size (ptr + ptr_size, ptr_size);
+      ptr += 2 * ptr_size;
+      if (low == 0 && high == 0)
+	break;
+
+      if (low == ~ (GElf_Addr) 0 || (ptr_size == 4 && low == 0xffffffff))
+	continue;
+
+      len = read_16 (ptr);
+      assert (ptr + len <= endsec);
+
+      adjust_exprloc (adj->cu, adj->cu->cu_die, adj->cu, adj->cu->cu_die,
+		      ptr, len);
+
+      ptr += len;
+    }
+
+  return 1;
+}
+
+/* Adjust .debug_loclists range determined by *SLOT, called through
+   htab_traverse.  */
+static int
+adjust_loclists (void **slot, void *data)
+{
+  struct debug_loc_adjust *adj = (struct debug_loc_adjust *) *slot;
+  unsigned char *ptr, *endsec;
+  size_t len = 0;
+
+  (void)data;
+
+  ptr = debug_sections[DEBUG_LOCLISTS].new_data + adj->start_offset;
+  endsec = ptr + debug_sections[DEBUG_LOCLISTS].size;
+
+again:
+  while (ptr < endsec)
+    {
+      uint8_t lle = *ptr++;
+      switch (lle)
+	{
+	case DW_LLE_end_of_list:
+	  goto done;
+
+	case DW_LLE_base_addressx:
+	  skip_leb128 (ptr);
+	  goto again;
+
+	case DW_LLE_startx_endx:
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  len = read_uleb128 (ptr);
+	  break;
+
+	case DW_LLE_startx_length:
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  len = read_uleb128 (ptr);
+	  break;
+
+	case DW_LLE_offset_pair:
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  len = read_uleb128 (ptr);
+	  break;
+
+	case DW_LLE_default_location:
+	  len = read_uleb128 (ptr);
+	  break;
+
+	case DW_LLE_base_address:
+	  ptr += ptr_size;
+	  goto again;
+
+	case DW_LLE_start_end:
+	  ptr += 2 * ptr_size;
+	  len = read_uleb128 (ptr);
+	  break;
+
+	case DW_LLE_start_length:
+	  ptr += ptr_size;
+	  skip_leb128 (ptr);
+	  len = read_uleb128 (ptr);
+	  break;
+
+	case DW_LLE_GNU_view_pair:
+	  /* Note we cannot check CU version here, but we'll get a
+	     warning on the original parsing if CU version is not 5.*/
+	  skip_leb128 (ptr);
+	  skip_leb128 (ptr);
+	  goto again;
+
+	default:
+	  error (0, 0, "unhandled location list entry 0x%x", lle);
+	  return 1;
+	}
+
+      assert (ptr + len <= endsec);
+
+      adjust_exprloc (adj->cu, adj->cu->cu_die, adj->cu, adj->cu->cu_die,
+		      ptr, len);
+
+      ptr += len;
+    }
+
+done:
+  return 1;
+}
+
+/* Create new .debug_loc section in malloced memory if .debug_loc
+   needs to be adjusted.  */
+static void
+write_loc (void)
+{
+  unsigned char *loc;
+  if (loc_htab == NULL)
+    return;
+  loc = malloc (debug_sections[DEBUG_LOC].size);
+  if (loc == NULL)
+    dwz_oom ();
+  memcpy (loc, debug_sections[DEBUG_LOC].data, debug_sections[DEBUG_LOC].size);
+  debug_sections[DEBUG_LOC].new_data = loc;
+  htab_traverse (loc_htab, adjust_loclist, NULL);
+}
+
+/* Create new .debug_loclists section in malloced memory if .debug_loclists
+   needs to be adjusted.  */
+static void
+write_loclists (void)
+{
+  unsigned char *loc;
+  if (loclists_htab == NULL)
+    return;
+  loc = malloc (debug_sections[DEBUG_LOCLISTS].size);
+  if (loc == NULL)
+    dwz_oom ();
+  memcpy (loc, debug_sections[DEBUG_LOCLISTS].data,
+	  debug_sections[DEBUG_LOCLISTS].size);
+  debug_sections[DEBUG_LOCLISTS].new_data = loc;
+  htab_traverse (loclists_htab, adjust_loclists, NULL);
+}
+
+/* Create new .debug_types section in malloced memory.  */
+static void
+write_types (void)
+{
+  dw_cu_ref cu;
+  unsigned char *types, *ptr, *inptr;
+  dw_die_ref ref;
+
+  if (debug_sections[DEBUG_TYPES].data == NULL)
+    return;
+  types = malloc (debug_sections[DEBUG_TYPES].new_size);
+  if (types == NULL)
+    dwz_oom ();
+  debug_sections[DEBUG_TYPES].new_data = types;
+  ptr = types;
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    {
+      unsigned long next_off = debug_sections[DEBUG_TYPES].new_size;
+      /* Ignore .debug_info CUs.  */
+      if (cu->cu_kind != CU_TYPES)
+	continue;
+      if (cu->cu_next)
+	next_off = cu->cu_next->cu_new_offset;
+      if (unlikely (low_mem)
+	  && expand_children (cu->cu_die))
+	recompute_abbrevs (cu, next_off - cu->cu_new_offset);
+      /* Write CU header.  */
+      write_32 (ptr, next_off - cu->cu_new_offset - 4);
+      write_16 (ptr, cu->cu_version);
+      write_32 (ptr, cu->u2.cu_new_abbrev_offset);
+      write_8 (ptr, ptr_size);
+      inptr = debug_sections[DEBUG_TYPES].data + cu->cu_offset + 19;
+      memcpy (ptr, inptr - 8, 8);
+      ptr += 8;
+      ref = off_htab_lookup (cu, cu->cu_offset + read_32 (inptr));
+      assert (ref && die_safe_dup(ref) == NULL);
+      write_32 (ptr, ref->u.p2.die_new_offset);
+      ptr = write_die (ptr, cu, cu->cu_die, NULL, NULL, NULL);
+      assert (types + next_off == ptr);
+      if (unlikely (low_mem))
+	collapse_children (cu, cu->cu_die);
+    }
+  assert (types + debug_sections[DEBUG_TYPES].new_size == ptr);
+}
+
+/* Construct new .debug_aranges section in malloced memory,
+   store it to debug_sections[DEBUG_ARANGES].new_data.  */
+static int
+write_aranges (DSO *dso)
+{
+  dw_cu_ref cu, cufirst = NULL, cucur;
+  unsigned char *aranges, *ptr, *end;
+
+  if (debug_sections[DEBUG_ARANGES].data == NULL)
+    return 0;
+
+  aranges = malloc (debug_sections[DEBUG_ARANGES].size);
+  if (aranges == NULL)
+    dwz_oom ();
+  memcpy (aranges, debug_sections[DEBUG_ARANGES].data,
+	  debug_sections[DEBUG_ARANGES].size);
+  debug_sections[DEBUG_ARANGES].new_data = aranges;
+  ptr = aranges;
+  end = aranges + debug_sections[DEBUG_ARANGES].size;
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    if (cu->cu_kind != CU_PU)
+      break;
+  cufirst = cu;
+  while (ptr < end)
+    {
+      unsigned int culen, value, cuoff;
+
+      if (end - ptr < 12)
+	{
+	  error (0, 0, "%s: Corrupted .debug_aranges section",
+		 dso->filename);
+	  return 1;
+	}
+      culen = read_32 (ptr);
+      if (culen >= 0xfffffff0)
+	{
+	  error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+	  return 1;
+	}
+
+      value = read_16 (ptr);
+      if (value != 2)
+	{
+	  error (0, 0, "%s: DWARF version %d in .debug_aranges unhandled",
+		 dso->filename, value);
+	  return 1;
+	}
+
+      cuoff = read_32 (ptr);
+      cucur = cu;
+      /* Optimistically assume that .debug_aranges CU offsets only increase,
+	 otherwise this might be too expensive and need a hash table.  */
+      for (; cu; cu = cu->cu_next)
+	{
+	  if (cu->cu_kind == CU_TYPES)
+	    {
+	      cu = NULL;
+	      break;
+	    }
+	  else if (cu->cu_offset == cuoff)
+	    break;
+	}
+      if (cu == NULL)
+	{
+	  for (cu = cufirst; cu != cucur; cu = cu->cu_next)
+	    if (cu->cu_offset == cuoff)
+	      break;
+	  if (cu == cucur)
+	    {
+	      error (0, 0, "%s: Couldn't find CU for .debug_aranges "
+			   "offset 0x%x", dso->filename, cuoff);
+	      return 1;
+	    }
+	}
+      if (unlikely (fi_multifile)
+	  && cu->cu_kind == CU_NORMAL
+	  && cu->cu_die->die_remove)
+	{
+	  error (0, 0, "%s: Partial unit referenced in .debug_aranges",
+		 dso->filename);
+	  return 1;
+	}
+      ptr -= 4;
+      write_32 (ptr, cu->cu_new_offset);
+      ptr += culen - 6;
+    }
+  return 0;
+}
+
+/* Helper function of write_gdb_index, called through qsort.
+   Sort an array of unsigned integer pairs, by increasing
+   first integer.  The first integer is the TU offset
+   in the .gdb_index TU table, the second is its index in
+   the TU table from the start of that table.  */
+static int
+gdb_index_tu_cmp (const void *p, const void *q)
+{
+  unsigned int *t1 = (unsigned int *) p;
+  unsigned int *t2 = (unsigned int *) q;
+
+  if (t1[0] < t2[0])
+    return -1;
+  if (t1[0] > t2[0])
+    return 1;
+
+  if (t1[1] < t2[1])
+    return -1;
+  if (t1[1] > t2[1])
+    return 1;
+  return 0;
+}
+
+/* Construct new .gdb_index section in malloced memory
+   if it needs adjustment.  */
+static void
+write_gdb_index (void)
+{
+  dw_cu_ref cu, cu_next, first_tu = NULL;
+  unsigned char *gdb_index, *ptr, *inptr, *end;
+  unsigned int ncus = 0, npus = 0, ntus = 0, ndelcus = 0, ver;
+  unsigned int culistoff, cutypesoff, addressoff, symboloff, constoff;
+  unsigned int *tuindices = NULL, tuidx = 0, *cumap = NULL, i, j, k;
+  bool fail = false;
+
+  debug_sections[GDB_INDEX].new_size = 0;
+  if (likely (!op_multifile)
+      && (debug_sections[GDB_INDEX].data == NULL
+	  || debug_sections[GDB_INDEX].size < 0x18))
+    return;
+  inptr = (unsigned char *) debug_sections[GDB_INDEX].data;
+  if (unlikely (op_multifile))
+    ver = multi_gdb_index_ver;
+  else
+    ver = buf_read_ule32 (inptr);
+  if (ver < 4 || ver > 8)
+    return;
+
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    if (cu->cu_kind == CU_PU)
+      npus++;
+    else if (cu->cu_kind == CU_NORMAL)
+      {
+	ncus++;
+	if (unlikely (fi_multifile) && cu->cu_die->die_remove)
+	  ndelcus++;
+      }
+    else if (cu->cu_kind == CU_TYPES)
+      ntus++;
+
+  /* Starting with version 7 CU indexes are limited to 24 bits,
+     so if we have more CUs, give up.  */
+  if (npus + ncus + ntus - ndelcus >= (1U << 24))
+    return;
+
+  if (unlikely (op_multifile))
+    {
+      assert (ncus == 0 && ntus == 0);
+      debug_sections[GDB_INDEX].new_size
+	= 0x18 + npus * 16 + 16;
+      gdb_index = malloc (debug_sections[GDB_INDEX].new_size);
+      if (gdb_index == NULL)
+	dwz_oom ();
+      debug_sections[GDB_INDEX].new_data = gdb_index;
+      /* Write new header.  */
+      buf_write_le32 (gdb_index + 0x00, ver);
+      buf_write_le32 (gdb_index + 0x04, 0x18);
+      buf_write_le32 (gdb_index + 0x08, 0x18 + npus * 16);
+      buf_write_le32 (gdb_index + 0x0c, 0x18 + npus * 16);
+      buf_write_le32 (gdb_index + 0x10, 0x18 + npus * 16);
+      buf_write_le32 (gdb_index + 0x14, 0x18 + npus * 16 + 16);
+      ptr = gdb_index + 0x18;
+      /* Write new CU list.  */
+      for (cu = first_cu; cu; cu = cu->cu_next)
+	{
+	  unsigned long next_off = debug_sections[DEBUG_INFO].new_size;
+	  if (cu->cu_next)
+	    next_off = cu->cu_next->cu_new_offset;
+	  buf_write_le64 (ptr, cu->cu_new_offset);
+	  buf_write_le64 (ptr + 8, next_off - cu->cu_new_offset);
+	  ptr += 16;
+	}
+      /* Write an empty hash table (with two entries).  */
+      memset (ptr, '\0', 16);
+      return;
+    }
+
+  culistoff = buf_read_ule32 (inptr + 0x04);
+  cutypesoff = buf_read_ule32 (inptr + 0x08);
+  addressoff = buf_read_ule32 (inptr + 0x0c);
+  symboloff = buf_read_ule32 (inptr + 0x10);
+  constoff = buf_read_ule32 (inptr + 0x14);
+  if (culistoff != 0x18
+      || cutypesoff != 0x18 + ncus * 16
+      || addressoff != cutypesoff + ntus * 24
+      || symboloff < addressoff
+      || ((symboloff - addressoff) % 20) != 0
+      || constoff < symboloff
+      || ((constoff - symboloff) & (constoff - symboloff - 1)) != 0
+      || ((constoff - symboloff) & 7) != 0
+      || debug_sections[GDB_INDEX].size < constoff)
+    return;
+  inptr += 0x18;
+  if (ndelcus)
+    cumap = (unsigned int *)
+	    obstack_alloc (&ob2, ncus * sizeof (unsigned int));
+  for (cu = first_cu, i = 0, j = 0; cu; cu = cu->cu_next)
+    if (cu->cu_kind == CU_NORMAL)
+      {
+	if (buf_read_ule64 (inptr) != cu->cu_offset)
+	  {
+	    if (cumap)
+	      obstack_free (&ob2, (void *) cumap);
+	    return;
+	  }
+	inptr += 16;
+	if (cumap)
+	  {
+	    if (cu->cu_die->die_remove)
+	      cumap[i++] = -1U;
+	    else
+	      cumap[i++] = j++;
+	  }
+      }
+    else if (cu->cu_kind == CU_TYPES)
+      {
+	if (tuindices == NULL)
+	  {
+	    tuindices = (unsigned int *)
+			obstack_alloc (&ob2, ntus * 2 * sizeof (unsigned int));
+	    first_tu = cu;
+	  }
+	tuindices[2 * tuidx] = buf_read_ule64 (inptr);
+	tuindices[2 * tuidx + 1] = tuidx * 24;
+	tuidx++;
+	inptr += 24;
+      }
+  if (ntus)
+    {
+      qsort (tuindices, ntus, 2 * sizeof (unsigned int), gdb_index_tu_cmp);
+      for (tuidx = 0, cu = first_tu; tuidx < ntus; tuidx++, cu = cu->cu_next)
+	if (tuindices[2 * tuidx] != cu->cu_offset)
+	  {
+	    if (cumap)
+	      obstack_free (&ob2, (void *) cumap);
+	    else
+	      obstack_free (&ob2, (void *) tuindices);
+	    return;
+	  }
+    }
+
+  if (multifile
+      && !fi_multifile
+      && !low_mem
+      && multi_gdb_index_ver < ver)
+    multi_gdb_index_ver = ver;
+
+  debug_sections[GDB_INDEX].new_size
+    = debug_sections[GDB_INDEX].size + npus * 16 - ndelcus * 16;
+  gdb_index = malloc (debug_sections[GDB_INDEX].new_size);
+  if (gdb_index == NULL)
+    dwz_oom ();
+  debug_sections[GDB_INDEX].new_data = gdb_index;
+  /* Write new header.  */
+  buf_write_le32 (gdb_index + 0x00, ver);
+  buf_write_le32 (gdb_index + 0x04, culistoff);
+  buf_write_le32 (gdb_index + 0x08, cutypesoff + npus * 16 - ndelcus * 16);
+  buf_write_le32 (gdb_index + 0x0c, addressoff + npus * 16 - ndelcus * 16);
+  buf_write_le32 (gdb_index + 0x10, symboloff + npus * 16 - ndelcus * 16);
+  buf_write_le32 (gdb_index + 0x14, constoff + npus * 16 - ndelcus * 16);
+  ptr = gdb_index + 0x18;
+  /* Write new CU list.  */
+  for (cu = first_cu; cu; cu = cu_next)
+    {
+      unsigned long next_off = debug_sections[DEBUG_INFO].new_size;
+      if (cu->cu_kind == CU_TYPES)
+	break;
+      cu_next = cu->cu_next;
+      if (unlikely (fi_multifile))
+	{
+	  while (cu_next
+		 && cu_next->cu_kind == CU_NORMAL
+		 && cu_next->cu_die->die_remove)
+	    cu_next = cu_next->cu_next;
+	  if (cu->cu_die->die_remove)
+	    continue;
+	}
+      if (cu_next && cu_next->cu_kind != CU_TYPES)
+	next_off = cu_next->cu_new_offset;
+      buf_write_le64 (ptr, cu->cu_new_offset);
+      buf_write_le64 (ptr + 8, next_off - cu->cu_new_offset);
+      ptr += 16;
+    }
+  /* Write new TU list.  */
+  for (tuidx = 0; cu; cu = cu->cu_next, tuidx++)
+    {
+      unsigned char *p;
+      unsigned int tuoff = tuindices[2 * tuidx + 1];
+      dw_die_ref ref;
+      assert (cu->cu_kind == CU_TYPES);
+      buf_write_le64 (ptr + tuoff, cu->cu_new_offset);
+      p = debug_sections[DEBUG_TYPES].data + cu->cu_offset + 19;
+      ref = off_htab_lookup (cu, cu->cu_offset + read_32 (p));
+      assert (ref && ref->die_dup == NULL);
+      buf_write_le64 (ptr + tuoff + 8, ref->u.p2.die_new_offset);
+      p -= 12;
+      buf_write_le64 (ptr + tuoff + 16, read_64 (p));
+    }
+  ptr += ntus * 24;
+  end = inptr + (symboloff - addressoff);
+  /* Copy address area, adjusting all CU indexes.  */
+  while (inptr < end)
+    {
+      memcpy (ptr, inptr, 16);
+      i = buf_read_ule32 (inptr + 16);
+      if (cumap && i < ncus)
+	{
+	  if (cumap[i] == -1U)
+	    fail = true;
+	  i = cumap[i] + npus;
+	}
+      else
+	i += npus - ndelcus;
+      buf_write_le32 (ptr + 16, i);
+      ptr += 20;
+      inptr += 20;
+    }
+  /* Copy the symbol hash table.  */
+  memcpy (ptr, inptr, constoff - symboloff);
+  /* Clear the const pool initially.  */
+  memset (ptr + (constoff - symboloff), '\0',
+	  debug_sections[GDB_INDEX].size - constoff);
+  ptr = ptr + (constoff - symboloff);
+  end = inptr + (constoff - symboloff);
+  /* Finally copy over const objects into the const pool, strings as is,
+     CU vectors with CU indexes adjusted.  */
+  while (inptr < end)
+    {
+      unsigned int name = buf_read_ule32 (inptr);
+      unsigned int cuvec = buf_read_ule32 (inptr + 4);
+
+      inptr += 8;
+      if (name == 0 && cuvec == 0)
+	continue;
+      if (name > debug_sections[GDB_INDEX].size - constoff - 1
+	  || cuvec > debug_sections[GDB_INDEX].size - constoff - 4)
+	{
+	fail:
+	  free (gdb_index);
+	  debug_sections[GDB_INDEX].new_size = 0;
+	  return;
+	}
+      if (ptr[name] == '\0')
+	{
+	  unsigned char *strend = end + name;
+	  while (*strend != '\0')
+	    {
+	      if (strend + 1
+		  == end + (debug_sections[GDB_INDEX].size - constoff))
+		goto fail;
+	      strend++;
+	    }
+	  memcpy (ptr + name, end + name, strend + 1 - (end + name));
+	}
+      if (buf_read_ule32 (ptr + cuvec) == 0)
+	{
+	  unsigned int count = buf_read_ule32 (end + cuvec);
+	  if (count * 4
+	      > debug_sections[GDB_INDEX].size - constoff - cuvec - 4)
+	    goto fail;
+	  buf_write_le32 (ptr + cuvec, count);
+	  for (i = 0; i < count; i++)
+	    {
+	      j = buf_read_ule32 (end + cuvec + (i + 1) * 4);
+	      if (ver >= 7)
+		k = j & ((1U << 24) - 1);
+	      else
+		k = j;
+	      if (cumap && k < ncus)
+		{
+		  if (cumap[k] == -1U)
+		    fail = true;
+		  k = cumap[k] + npus;
+		}
+	      else
+		k += npus - ndelcus;
+	      if (ver >= 7)
+		j = (j & (~0U << 24)) | k;
+	      else
+		j = k;
+	      buf_write_le32 (ptr + cuvec + (i + 1) * 4, j);
+	    }
+	}
+    }
+  if (cumap)
+    obstack_free (&ob2, (void *) cumap);
+  else if (tuindices)
+    obstack_free (&ob2, (void *) tuindices);
+  if (fail)
+    {
+      free (debug_sections[GDB_INDEX].new_data);
+      debug_sections[GDB_INDEX].new_data = NULL;
+      debug_sections[GDB_INDEX].new_size = 0;
+    }
+}
+
+/* Return a string from section SEC at offset OFFSET.  */
+static const char *
+strptr (DSO *dso, int sec, off_t offset)
+{
+  Elf_Scn *scn;
+  Elf_Data *data;
+
+  scn = dso->scn[sec];
+  if (offset >= 0 && (GElf_Addr) offset < dso->shdr[sec].sh_size)
+    {
+      data = NULL;
+      while ((data = elf_rawdata (scn, data)) != NULL)
+	{
+	  if (data->d_buf
+	      && offset >= data->d_off
+	      && offset < (off_t) (data->d_off + data->d_size))
+	    return (const char *) data->d_buf + (offset - data->d_off);
+	}
+    }
+
+  return NULL;
+}
+
+/* Initialize do_read_* and do_write_* callbacks based on
+   ENDIANITY.  */
+static void
+init_endian (int endianity)
+{
+  if (endianity == ELFDATA2LSB)
+    {
+      do_read_16 = buf_read_ule16;
+      do_read_32 = buf_read_ule32;
+      do_read_64 = buf_read_ule64;
+      do_write_16 = buf_write_le16;
+      do_write_32 = buf_write_le32;
+      do_write_64 = buf_write_le64;
+    }
+  else if (endianity == ELFDATA2MSB)
+    {
+      do_read_16 = buf_read_ube16;
+      do_read_32 = buf_read_ube32;
+      do_read_64 = buf_read_ube64;
+      do_write_16 = buf_write_be16;
+      do_write_32 = buf_write_be32;
+      do_write_64 = buf_write_be64;
+    }
+  else
+    abort ();
+}
+
+/* Read DWARF sections from DSO.  */
+static int
+read_dwarf (DSO *dso, bool quieter, unsigned int *die_count)
+{
+  Elf_Data *data;
+  Elf_Scn *scn;
+  int i, j;
+
+  for (i = 1; i < dso->ehdr.e_shnum; ++i)
+    if (! (dso->shdr[i].sh_flags & (SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR))
+	&& dso->shdr[i].sh_size)
+      {
+	const char *name = strptr (dso, dso->ehdr.e_shstrndx,
+				   dso->shdr[i].sh_name);
+
+	if (strncmp (name, ".debug_", sizeof (".debug_") - 1) == 0
+	    || strcmp (name, ".gdb_index") == 0
+	    || strcmp (name, ".gnu_debugaltlink") == 0)
+	  {
+	    if (dso->shdr[i].sh_flags & SHF_COMPRESSED)
+	      {
+		error (0, 0,
+		       "%s: Found compressed %s section, not attempting dwz"
+		       " compression",
+		       dso->filename, name);
+		return 1;
+	      }
+	    for (j = 0; debug_sections[j].name; ++j)
+	      if (strcmp (name, debug_sections[j].name) == 0)
+		{
+		  if (debug_sections[j].data)
+		    {
+		      error (0, 0, "%s: Found two copies of %s section",
+			     dso->filename, name);
+		      return 1;
+		    }
+
+		  scn = dso->scn[i];
+		  data = elf_rawdata (scn, NULL);
+		  assert (data != NULL);
+		  if (data->d_buf == NULL)
+		    {
+		      error (0, 0, "%s: Found empty %s section, not attempting"
+			     " dwz compression", dso->filename, name);
+		      return 1;
+		    }
+		  assert (elf_rawdata (scn, data) == NULL);
+		  assert (data->d_off == 0);
+		  assert (data->d_size == dso->shdr[i].sh_size);
+		  debug_sections[j].data = data->d_buf;
+		  debug_sections[j].size = data->d_size;
+		  debug_sections[j].new_size = data->d_size;
+		  debug_sections[j].sec = i;
+		  break;
+		}
+
+	    if (debug_sections[j].name == NULL)
+	      {
+		error (0, 0, "%s: Unknown debugging section %s",
+		       dso->filename, name);
+		return 1;
+	      }
+	  }
+      }
+
+  if (dso->ehdr.e_ident[EI_DATA] == ELFDATA2LSB
+      || dso->ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
+    init_endian (dso->ehdr.e_ident[EI_DATA]);
+  else
+    {
+      error (0, 0, "%s: Wrong ELF data encoding", dso->filename);
+      return 1;
+    }
+
+  if (debug_sections[DEBUG_INFO].data == NULL
+      && !rd_multifile)
+    {
+      if (!quieter)
+	error (0, 0, "%s: .debug_info section not present",
+	       dso->filename);
+      return 3;
+    }
+
+  if (debug_sections[DEBUG_SUP].data != NULL && !(dwarf_5 && rd_multifile))
+    {
+      error (0, 0, "%s: .debug_sup section already present",
+	     dso->filename);
+      return 1;
+    }
+
+  if (debug_sections[GNU_DEBUGALTLINK].data != NULL)
+    {
+      error (0, 0, "%s: .gnu_debugaltlink section already present",
+	     dso->filename);
+      return 1;
+    }
+
+  int res;
+  res = read_debug_info (dso, DEBUG_INFO, die_count);
+  if (res == 0 && stats_p)
+    print_parse_stats ();
+  return res;
+}
+
+/* Open an ELF file NAME.  */
+static DSO *
+fdopen_dso (int fd, const char *name)
+{
+  Elf *elf = NULL;
+  GElf_Ehdr ehdr;
+  int i;
+  DSO *dso = NULL;
+
+  elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
+  if (elf == NULL)
+    {
+      error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1));
+      goto error_out;
+    }
+
+  if (elf_kind (elf) != ELF_K_ELF)
+    {
+      error (0, 0, "\"%s\" is not an ELF file", name);
+      goto error_out;
+    }
+
+  if (gelf_getehdr (elf, &ehdr) == NULL)
+    {
+      error (0, 0, "cannot get the ELF header: %s",
+	     elf_errmsg (-1));
+      goto error_out;
+    }
+
+  if (ehdr.e_type != ET_DYN && ehdr.e_type != ET_EXEC
+      && (!rd_multifile || ehdr.e_type != ET_REL))
+    {
+      error (0, 0, "\"%s\" is not a shared library", name);
+      goto error_out;
+    }
+
+  /* Allocate DSO structure.  */
+  dso = (DSO *)
+	malloc (sizeof(DSO) + ehdr.e_shnum * sizeof(GElf_Shdr)
+		+ ehdr.e_shnum * sizeof(Elf_Scn *)
+		+ strlen (name) + 1);
+  if (!dso)
+    {
+      error (0, ENOMEM, "Could not open DSO");
+      goto error_out;
+    }
+
+  elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT | ELF_F_PERMISSIVE);
+
+  memset (dso, 0, sizeof(DSO));
+  dso->elf = elf;
+  dso->ehdr = ehdr;
+  dso->scn = (Elf_Scn **) &dso->shdr[ehdr.e_shnum];
+
+  for (i = 0; i < ehdr.e_shnum; ++i)
+    {
+      dso->scn[i] = elf_getscn (elf, i);
+      gelf_getshdr (dso->scn[i], dso->shdr + i);
+    }
+
+  dso->filename = (const char *) &dso->scn[ehdr.e_shnum];
+  strcpy ((char *) &dso->scn[ehdr.e_shnum], name);
+  return dso;
+
+error_out:
+  free (dso);
+  if (elf)
+    elf_end (elf);
+  if (fd != -1)
+    close (fd);
+  return NULL;
+}
+
+/* Implicit arg for compare_section_numbers.  Could be passed in as explicit arg
+   when using qsort_r instead.  */
+static DSO *compare_section_numbers_implicit_arg;
+
+/* Helper function for sort_section_numbers.  */
+static int
+compare_section_numbers (const void *p1, const void *p2)
+{
+  DSO *dso = compare_section_numbers_implicit_arg;
+  const int i1 = *(const int *)p1;
+  const int i2 = *(const int *)p2;
+  GElf_Off o1;
+  GElf_Off o2;
+
+  /* Keep element 0 at 0.  */
+  if (i1 == 0 || i2 == 0)
+    {
+      if (i1 == i2)
+	return 0;
+      if (i1 == 0)
+	return -1;
+      if (i2 == 0)
+	return 1;
+    }
+
+  /* Get file offsets.  */
+  o1 = (i1 == dso->ehdr.e_shnum
+	? dso->ehdr.e_shoff
+	: dso->shdr[i1].sh_offset);
+  o2 = (i2 == dso->ehdr.e_shnum
+	? dso->ehdr.e_shoff
+	: dso->shdr[i2].sh_offset);
+
+  /* Compare file offsets.  */
+  if (o1 < o2)
+    return -1;
+  if (o1 > o2)
+    return 1;
+
+  /* In case file offset is the same, keep the original relative order.  */
+  if (i1 < i2)
+    return -1;
+  if (i1 > i2)
+    return 1;
+
+  return 0;
+}
+
+/* Sort SORTED_SECTION_NUMBERS in file offset order.  */
+static void
+sort_section_numbers (DSO *dso, unsigned int *sorted_section_numbers)
+{
+  unsigned int i;
+  unsigned int nr_sections = dso->ehdr.e_shnum;
+
+  /* Treat section header table as another section, with index
+     dso->ehdr.e_shnum.  */
+  nr_sections += 1;
+
+  for (i = 0; i < nr_sections; ++i)
+    sorted_section_numbers[i] = i;
+
+  compare_section_numbers_implicit_arg = dso;
+  qsort (sorted_section_numbers, nr_sections,
+	 sizeof (sorted_section_numbers[0]), compare_section_numbers);
+  compare_section_numbers_implicit_arg = NULL;
+
+  assert (sorted_section_numbers[0] == 0);
+}
+
+/* Verify file offset and size of sections and section header table.  */
+static void
+verify_sections (DSO *dso, unsigned int *sorted_section_numbers,
+		 GElf_Off *distance, int addsec, GElf_Off addsize,
+		 GElf_Ehdr ehdr)
+{
+  int i, j;
+  int prev, update_prev;
+  GElf_Off offset, prev_offset, prev_size;
+  GElf_Off section_header_table_size
+    = dso->ehdr.e_shentsize * ehdr.e_shnum;
+
+  prev = -1;
+  for (i = 1; i < (dso->ehdr.e_shnum + 1); ++i, prev = update_prev)
+    {
+      j = sorted_section_numbers[i];
+
+      if (j != dso->ehdr.e_shnum && dso->shdr[j].sh_type == SHT_NOBITS)
+	{
+	  update_prev = prev;
+	  continue;
+	}
+      update_prev = j;
+
+      if (prev == -1)
+	continue;
+
+      offset = (j == dso->ehdr.e_shnum
+		? ehdr.e_shoff
+		: dso->shdr[j].sh_offset);
+
+      prev_offset = (prev == dso->ehdr.e_shnum
+		     ? ehdr.e_shoff
+		     : dso->shdr[prev].sh_offset);
+
+      prev_size = (prev == dso->ehdr.e_shnum
+		   ? section_header_table_size
+		   : (dso->shdr[prev].sh_type == SHT_NOBITS
+		      ? 0
+		      : dso->shdr[prev].sh_size));
+
+      if (distance != NULL)
+	assert ((prev_offset + prev_size + distance[prev]
+		 + (prev == addsec ? addsize : 0))
+		== offset);
+      else
+	assert ((prev_offset + prev_size + (prev == addsec ? addsize : 0))
+		<= offset);
+    }
+}
+
+/* Calculate distance between sections and section header table.  */
+static int
+calculate_section_distance (DSO *dso, unsigned int *sorted_section_numbers,
+			    GElf_Off *distance)
+{
+  int i, j;
+  int prev, update_prev;
+  GElf_Off offset, prev_offset, prev_size;
+  GElf_Off section_header_table_size
+    = dso->ehdr.e_shentsize * dso->ehdr.e_shnum;
+
+  prev = -1;
+  for (i = 1; i < (dso->ehdr.e_shnum + 1); ++i, prev = update_prev)
+    {
+      j = sorted_section_numbers[i];
+
+      if (j != dso->ehdr.e_shnum && dso->shdr[j].sh_type == SHT_NOBITS)
+	{
+	  update_prev = prev;
+	  continue;
+	}
+      update_prev = j;
+
+      if (prev == -1)
+	continue;
+
+      offset = (j == dso->ehdr.e_shnum
+		? dso->ehdr.e_shoff
+		: dso->shdr[j].sh_offset);
+
+      prev_offset = (prev == dso->ehdr.e_shnum
+		     ? dso->ehdr.e_shoff
+		     : dso->shdr[prev].sh_offset);
+
+      prev_size = (prev == dso->ehdr.e_shnum
+		   ? section_header_table_size
+		   : dso->shdr[prev].sh_size);
+
+      if (prev_offset + prev_size > offset)
+	{
+	  error (0, 0, "Section overlap detected");
+	  if (prev == dso->ehdr.e_shnum)
+	    error (0, 0, "Section header table: [0x%llx, 0x%llx)",
+		   (unsigned long long)prev_offset,
+		   (unsigned long long)(prev_offset + prev_size));
+	  else
+	    error (0, 0, "Section %d: [0x%llx, 0x%llx)", j,
+		   (unsigned long long)prev_offset,
+		   (unsigned long long)(prev_offset + prev_size));
+	  if (j == dso->ehdr.e_shnum)
+	    error (0, 0, "Section header table: 0x%llx",
+		   (unsigned long long)offset);
+	  else
+	    error (0, 0, "Section %d: 0x%llx", j, (unsigned long long)offset);
+	  return 1;
+	}
+
+      distance[prev] = offset - (prev_offset + prev_size);
+    }
+
+  verify_sections (dso, sorted_section_numbers, distance, -1, 0, dso->ehdr);
+
+  return 0;
+}
+
+/* Store new ELF into FILE.  debug_sections array contains
+   new_data/new_size pairs where needed.  */
+static int
+write_dso (DSO *dso, const char *file, struct stat *st, bool save_to_temp)
+{
+  Elf *elf = NULL;
+  GElf_Ehdr ehdr;
+  GElf_Off min_shoff = ~(GElf_Off) 0;
+  char *e_ident;
+  int fd, i, j, addsec = -1, ret;
+  GElf_Off off, diff, addsize = 0;
+  char *filename = NULL;
+  GElf_Word shstrtabadd = 0;
+  char *shstrtab = NULL;
+  bool remove_sections[SECTION_COUNT];
+  GElf_Off distance[dso->ehdr.e_shnum + 1];
+  /* Array of sections and section header table sorted by file offset.  */
+  unsigned int sorted_section_numbers[dso->ehdr.e_shnum + 1];
+  GElf_Off old_sh_offset[dso->ehdr.e_shnum];
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "write_dso\n");
+    }
+
+  for (i = 1; i < dso->ehdr.e_shnum; ++i)
+    old_sh_offset[i] = dso->shdr[i].sh_offset;
+
+  memset (remove_sections, '\0', sizeof (remove_sections));
+  ehdr = dso->ehdr;
+
+  sort_section_numbers (dso, sorted_section_numbers);
+  if (calculate_section_distance (dso, sorted_section_numbers, distance))
+    return 1;
+
+  for (i = 0; debug_sections[i].name; i++)
+    if (debug_sections[i].new_size != debug_sections[i].size)
+      {
+	if (debug_sections[i].size == 0
+	    && debug_sections[i].sec == 0)
+	  {
+	    unsigned int len;
+	    if (addsec == -1)
+	      for (j = 0; debug_sections[j].name; j++)
+		if (debug_sections[j].new_size
+		    && debug_sections[j].sec
+		    && debug_sections[j].sec > addsec)
+		  addsec = debug_sections[j].sec;
+	    ehdr.e_shnum++;
+	    if (ehdr.e_shoff < min_shoff)
+	      min_shoff = ehdr.e_shoff;
+	    for (j = 1; j < dso->ehdr.e_shnum; ++j)
+	      {
+		if (dso->shdr[j].sh_offset > ehdr.e_shoff)
+		  dso->shdr[j].sh_offset += ehdr.e_shentsize;
+		if (dso->shdr[j].sh_link > (unsigned int) addsec)
+		  dso->shdr[j].sh_link++;
+		if ((dso->shdr[j].sh_type == SHT_REL
+		     || dso->shdr[j].sh_type == SHT_RELA
+		     || (dso->shdr[j].sh_flags & SHF_INFO_LINK))
+		    && dso->shdr[j].sh_info
+		       > (unsigned int) addsec)
+		  dso->shdr[j].sh_info++;
+	      }
+	    if (dso->ehdr.e_shstrndx > addsec)
+	      ehdr.e_shstrndx++;
+	    len = strlen (debug_sections[i].name) + 1;
+	    dso->shdr[dso->ehdr.e_shstrndx].sh_size += len;
+	    if (dso->shdr[dso->ehdr.e_shstrndx].sh_offset < min_shoff)
+	      min_shoff = dso->shdr[dso->ehdr.e_shstrndx].sh_offset;
+	    for (j = 1; j < dso->ehdr.e_shnum; ++j)
+	      if (dso->shdr[j].sh_offset
+		  > dso->shdr[dso->ehdr.e_shstrndx].sh_offset)
+		dso->shdr[j].sh_offset += len;
+	    if (ehdr.e_shoff > dso->shdr[dso->ehdr.e_shstrndx].sh_offset)
+	      ehdr.e_shoff += len;
+	    shstrtabadd += len;
+	    diff = debug_sections[i].new_size;
+	    addsize += diff;
+	    off = dso->shdr[addsec].sh_offset;
+	  }
+	else
+	  {
+	    diff = (GElf_Off) debug_sections[i].new_size
+		   - (GElf_Off) dso->shdr[debug_sections[i].sec].sh_size;
+	    off = dso->shdr[debug_sections[i].sec].sh_offset;
+	  }
+	if (off < min_shoff)
+	  min_shoff = off;
+	for (j = 1; j < dso->ehdr.e_shnum; ++j)
+	  if (dso->shdr[j].sh_offset > off)
+	    dso->shdr[j].sh_offset += diff;
+	if (ehdr.e_shoff > off)
+	  ehdr.e_shoff += diff;
+	dso->shdr[debug_sections[i].sec].sh_size
+	  = debug_sections[i].new_size;
+	if (debug_sections[i].new_size == 0)
+	  {
+	    remove_sections[i] = true;
+	    ehdr.e_shnum--;
+	    if (ehdr.e_shoff < min_shoff)
+	      min_shoff = ehdr.e_shoff;
+	    for (j = 1; j < dso->ehdr.e_shnum; ++j)
+	      {
+		if (dso->shdr[j].sh_offset > ehdr.e_shoff)
+		  dso->shdr[j].sh_offset -= ehdr.e_shentsize;
+		if (dso->shdr[j].sh_link
+		    > (unsigned int) debug_sections[i].sec)
+		  dso->shdr[j].sh_link--;
+		if ((dso->shdr[j].sh_type == SHT_REL
+		     || dso->shdr[j].sh_type == SHT_RELA
+		     || (dso->shdr[j].sh_flags & SHF_INFO_LINK))
+		    && dso->shdr[j].sh_info
+		       > (unsigned int) debug_sections[i].sec)
+		  dso->shdr[j].sh_info--;
+	      }
+	    if (dso->ehdr.e_shstrndx > debug_sections[i].sec)
+	      ehdr.e_shstrndx--;
+	  }
+      }
+
+  /* Verify that we did not change section layout, by checking that the
+     distances between sections and section header table remained the same.  */
+  verify_sections (dso, sorted_section_numbers, distance, addsec, addsize,
+		   ehdr);
+
+  if (min_shoff != ~(GElf_Off) 0)
+    {
+      for (j = 1; j < dso->ehdr.e_shnum; ++j)
+	if (dso->shdr[j].sh_offset >= min_shoff
+	    && dso->shdr[j].sh_addralign > 1
+	    && (dso->shdr[j].sh_offset & (dso->shdr[j].sh_addralign - 1)) != 0)
+	  break;
+      if (j < dso->ehdr.e_shnum
+	  || (ehdr.e_shoff >= min_shoff
+	      && (ehdr.e_shoff & (ehdr.e_ident[EI_CLASS] == ELFCLASS64
+				  ? 7 : 3)) != 0))
+	{
+	  /* Need to fix up sh_offset/e_shoff.  Punt if all the sections
+	     >= min_shoff aren't non-ALLOC.  */
+	  GElf_Off last_shoff = 0;
+	  int k = -1;
+	  int l;
+	  for (l = 1; l <= dso->ehdr.e_shnum; ++l)
+	    {
+	      j = sorted_section_numbers[l];
+	      if (j == dso->ehdr.e_shnum)
+		continue;
+	      else if (!last_shoff
+		       && (dso->shdr[j].sh_offset < min_shoff
+			   || (dso->shdr[j].sh_offset == min_shoff
+			       && (dso->shdr[j].sh_size == 0
+				   || dso->shdr[j].sh_type == SHT_NOBITS))))
+		continue;
+	      else if (dso->shdr[j].sh_type == SHT_NOBITS)
+		continue;
+	      else if ((dso->shdr[j].sh_flags & SHF_ALLOC) != 0)
+		{
+		  error (0, 0, "Allocatable section in %s after "
+			 "non-allocatable ones", dso->filename);
+		  return 1;
+		}
+	      else
+		{
+		  assert (dso->shdr[j].sh_offset >= last_shoff);
+
+		  if (k == -1)
+		    k = l;
+		  last_shoff = dso->shdr[j].sh_offset + dso->shdr[j].sh_size;
+		}
+	    }
+	  last_shoff = min_shoff;
+	  for (l = k; l <= dso->ehdr.e_shnum; ++l)
+	    {
+	      j = sorted_section_numbers[l];
+	      if (j == dso->ehdr.e_shnum)
+		{
+		  if (ehdr.e_ident[EI_CLASS] == ELFCLASS64)
+		    ehdr.e_shoff = (last_shoff + 7) & -8;
+		  else
+		    ehdr.e_shoff = (last_shoff + 3) & -4;
+		  last_shoff = ehdr.e_shoff + ehdr.e_shnum * ehdr.e_shentsize;
+		  continue;
+		}
+	      /* Ignore SHT_NOBITS sections.  */
+	      if (dso->shdr[j].sh_type == SHT_NOBITS)
+		continue;
+	      dso->shdr[j].sh_offset = last_shoff;
+	      if (dso->shdr[j].sh_addralign > 1)
+		dso->shdr[j].sh_offset
+		  = (last_shoff + dso->shdr[j].sh_addralign - 1)
+		    & ~(dso->shdr[j].sh_addralign - (GElf_Off) 1);
+	      last_shoff = dso->shdr[j].sh_offset + dso->shdr[j].sh_size;
+	      if (addsec != -1 && j == addsec)
+		last_shoff += addsize;
+	    }
+	}
+    }
+
+  for (i = 1; i < dso->ehdr.e_shnum; ++i)
+    if (dso->shdr[i].sh_type == SHT_NOBITS)
+      dso->shdr[i].sh_offset = old_sh_offset[i];
+
+  verify_sections (dso, sorted_section_numbers, NULL, addsec, addsize,
+		   ehdr);
+
+  if (shstrtabadd != 0)
+    {
+      shstrtab = (char *) malloc (dso->shdr[dso->ehdr.e_shstrndx].sh_size);
+      if (shstrtab == NULL)
+	{
+	  error (0, ENOMEM, "Failed to adjust .shstrtab for %s",
+		 dso->filename);
+	  return 1;
+	}
+    }
+
+  if (file == NULL)
+    {
+      size_t len = strlen (dso->filename);
+      filename = alloca (len + sizeof (".#dwz#.XXXXXX"));
+      memcpy (filename, dso->filename, len);
+      memcpy (filename + len, ".#dwz#.XXXXXX", sizeof (".#dwz#.XXXXXX"));
+      fd = mkstemp (filename);
+      file = (const char *) filename;
+      if (fd == -1)
+	{
+	  error (0, errno, "Failed to create temporary file for %s",
+		 dso->filename);
+	  free (shstrtab);
+	  return 1;
+	}
+    }
+  else
+    {
+      fd = open (file, O_RDWR | O_CREAT, 0600);
+      if (fd == -1)
+	{
+	  error (0, errno, "Failed to open %s for writing", file);
+	  free (shstrtab);
+	  return 1;
+	}
+    }
+
+  elf = elf_begin (fd, ELF_C_WRITE, NULL);
+  if (elf == NULL)
+    {
+      error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1));
+      unlink (file);
+      close (fd);
+      free (shstrtab);
+      return 1;
+    }
+
+  /* Some gelf_newehdr implementations don't return the resulting
+     ElfNN_Ehdr, so we have to do it the hard way instead of:
+     e_ident = (char *) gelf_newehdr (elf, gelf_getclass (dso->elf));  */
+  switch (gelf_getclass (dso->elf))
+    {
+    case ELFCLASS32:
+      e_ident = (char *) elf32_newehdr (elf);
+      break;
+    case ELFCLASS64:
+      e_ident = (char *) elf64_newehdr (elf);
+      break;
+    default:
+      e_ident = NULL;
+      break;
+    }
+
+  if (e_ident == NULL
+      /* This is here just for the gelfx wrapper, so that gelf_update_ehdr
+	 already has the correct ELF class.  */
+      || memcpy (e_ident, dso->ehdr.e_ident, EI_NIDENT) == NULL
+      || gelf_update_ehdr (elf, &ehdr) == 0
+      || gelf_newphdr (elf, ehdr.e_phnum) == 0)
+    {
+      error (0, 0, "Could not create new ELF headers");
+      unlink (file);
+      elf_end (elf);
+      close (fd);
+      free (shstrtab);
+      return 1;
+    }
+  elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT | ELF_F_PERMISSIVE);
+  for (i = 0; i < ehdr.e_phnum; ++i)
+    {
+      GElf_Phdr *phdr, phdr_mem;
+      phdr = gelf_getphdr (dso->elf, i, &phdr_mem);
+      gelf_update_phdr (elf, i, phdr);
+    }
+
+  for (i = 1; i < dso->ehdr.e_shnum; ++i)
+    {
+      Elf_Scn *scn;
+      Elf_Data *data1, *data2;
+
+      for (j = 0; debug_sections[j].name; j++)
+	if (i == debug_sections[j].sec)
+	  break;
+      if (debug_sections[j].name && remove_sections[j])
+	continue;
+      scn = elf_newscn (elf);
+      elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+      gelf_update_shdr (scn, &dso->shdr[i]);
+      data1 = elf_getdata (dso->scn[i], NULL);
+      data2 = elf_newdata (scn);
+      memcpy (data2, data1, sizeof (*data1));
+      if (debug_sections[j].name
+	  && debug_sections[j].new_data != NULL)
+	{
+	  data2->d_buf = debug_sections[j].new_data;
+	  data2->d_size = dso->shdr[i].sh_size;
+	}
+      if (i == dso->ehdr.e_shstrndx && shstrtabadd)
+	{
+	  memcpy (shstrtab, data1->d_buf,
+		  dso->shdr[dso->ehdr.e_shstrndx].sh_size
+		  - shstrtabadd);
+	  data2->d_buf = shstrtab;
+	  data2->d_size = dso->shdr[i].sh_size;
+	}
+      if (i == addsec)
+	{
+	  GElf_Word sh_name = dso->shdr[dso->ehdr.e_shstrndx].sh_size
+			      - shstrtabadd;
+	  GElf_Shdr shdr;
+
+	  off = dso->shdr[i].sh_offset + dso->shdr[i].sh_size;
+	  for (j = 0; debug_sections[j].name; j++)
+	    if (debug_sections[j].new_size
+		&& debug_sections[j].size == 0
+		&& debug_sections[j].sec == 0)
+	      {
+		scn = elf_newscn (elf);
+		elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+		memset (&shdr, '\0', sizeof (shdr));
+		shdr.sh_name = sh_name;
+		sh_name += strlen (debug_sections[j].name) + 1;
+		strcpy (shstrtab + shdr.sh_name, debug_sections[j].name);
+		shdr.sh_type = SHT_PROGBITS;
+		shdr.sh_offset = off;
+		shdr.sh_size = debug_sections[j].new_size;
+		shdr.sh_addralign = 1;
+		off += shdr.sh_size;
+		gelf_update_shdr (scn, &shdr);
+		data2 = elf_newdata (scn);
+		data2->d_buf = debug_sections[j].new_data;
+		data2->d_type = ELF_T_BYTE;
+		data2->d_version = EV_CURRENT;
+		data2->d_size = shdr.sh_size;
+		data2->d_off = 0;
+		data2->d_align = 1;
+	      }
+	}
+    }
+
+  if (elf_update (elf, ELF_C_WRITE_MMAP) == -1)
+    {
+      error (0, 0, "%s: elf_update failed", dso->filename);
+      unlink (file);
+      elf_end (elf);
+      close (fd);
+      free (shstrtab);
+      return 1;
+    }
+
+  if (elf_end (elf) < 0)
+    {
+      error (0, 0, "elf_end failed: %s", elf_errmsg (elf_errno ()));
+      unlink (file);
+      elf_end (elf);
+      close (fd);
+      free (shstrtab);
+      return 1;
+    }
+
+  free (shstrtab);
+  ret = fchown (fd, st->st_uid, st->st_gid);
+  fchmod (fd, st->st_mode & 07777);
+  close (fd);
+
+  if (filename != NULL && rename (filename, dso->filename))
+    {
+      error (0, errno, "Failed to rename temporary file over %s",
+	     dso->filename);
+      unlink (file);
+      /* | (ret & 1) to silence up __wur warning for fchown.  */
+      return 1 | (ret & 1);
+    }
+  if (save_to_temp)
+    {
+      const char *prefix = "dwz.";
+      size_t buf_len = strlen (prefix) + strlen (dso->filename) + 1;
+      char *buf = (char *)alloca (buf_len);
+      size_t offset = 0;
+      strcpy (&buf[offset], prefix);
+      offset += strlen (prefix);
+      strcpy (&buf[offset], dso->filename);
+      offset += strlen (dso->filename);
+      assert (offset == buf_len - 1);
+      assert (buf[offset] == '\0');
+      unlink (buf);
+      if (link (dso->filename, buf) != 0)
+	{
+	  error (0, errno, "Failed to link file: %s", dso->filename);
+	  return 1;
+	}
+    }
+  return 0;
+}
+
+/* Free memory and clear global variables.  */
+static void
+cleanup (void)
+{
+  dw_cu_ref cu;
+  unsigned int i;
+
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    {
+      if (cu->cu_new_abbrev)
+	htab_delete (cu->cu_new_abbrev);
+      cu->cu_new_abbrev = NULL;
+    }
+  if (off_htab != NULL)
+    {
+      if (tracing)
+	htab_report (off_htab, "off_htab final");
+      htab_delete (off_htab);
+    }
+  off_htab = NULL;
+  if (types_off_htab != NULL)
+    htab_delete (types_off_htab);
+  types_off_htab = NULL;
+  if (loc_htab != NULL)
+    htab_delete (loc_htab);
+  loc_htab = NULL;
+  if (loclists_htab != NULL)
+    htab_delete (loclists_htab);
+  loclists_htab = NULL;
+  if (dup_htab != NULL)
+    htab_delete (dup_htab);
+  dup_htab = NULL;
+  if (strp_htab != NULL)
+    htab_delete (strp_htab);
+  strp_htab = NULL;
+  if (line_htab != NULL)
+    htab_delete (line_htab);
+  line_htab = NULL;
+  if (macro_htab != NULL)
+    htab_delete (macro_htab);
+  macro_htab = NULL;
+  if (meta_abbrev_htab != NULL)
+    htab_delete (meta_abbrev_htab);
+  meta_abbrev_htab = NULL;
+
+  for (i = 0; i < SAVED_SECTIONS; ++i)
+    {
+      free (saved_new_data[i]);
+      saved_new_data[i] = NULL;
+    }
+
+  obstack_free (&ob2, NULL);
+  obstack_free (&ob, NULL);
+  memset (&ob2, '\0', sizeof (ob2));
+  memset (&ob, '\0', sizeof (ob2));
+  die_nontoplevel_freelist = NULL;
+  die_collapsed_child_freelist = NULL;
+  pool_destroy (NULL);
+  first_cu = NULL;
+  last_cu = NULL;
+  ptr_size = 0;
+  max_nattr = 0;
+  do_read_16 = NULL;
+  do_read_32 = NULL;
+  do_read_64 = NULL;
+  do_write_16 = NULL;
+  do_write_32 = NULL;
+  do_write_64 = NULL;
+  edge_freelist = NULL;
+  multifile_mode = 0;
+  max_strp_off = 0;
+  max_line_id = 0;
+}
+
+/* Propagate the die_no_multifile property along the duplicate chain of which
+   DIE is a member.  If the property was changed on any die, set *CHANGED to
+   true.  */
+static void
+propagate_multifile_duplicate_chain (dw_die_ref die, bool *changed)
+{
+  dw_die_ref dup = first_dup (die);
+  if (!dup)
+    return;
+
+  while (dup && dup->die_offset == -1U)
+    dup = dup->die_nextdup;
+  if (dup != die)
+    return;
+
+  bool any_no_multifile = false;
+  bool any_multifile = false;
+  bool prop_needed = false;
+  dw_die_ref d;
+  for (d = dup; d && !prop_needed; d = d->die_nextdup)
+    {
+      if (d->die_no_multifile)
+	any_no_multifile = true;
+      else
+	any_multifile = true;
+      prop_needed = any_no_multifile && any_multifile;
+    }
+  if (!prop_needed)
+    return;
+
+  *changed = true;
+
+  for (d = dup; d; d = d->die_nextdup)
+    d->die_no_multifile = 1;
+}
+
+/* Propagate the die_no_multifile property backwards along the outgoing
+   references of DIE, which is a member of CU and of the subtree of lower
+   toplevel die TOP_DIE.  If the property was changed on any die, set *CHANGED
+   to true.  */
+static void
+propagate_multifile_refs_backward (dw_cu_ref cu, dw_die_ref top_die,
+				   dw_die_ref die, bool *changed)
+{
+  struct abbrev_tag *t = die->die_abbrev;
+  unsigned int i;
+  unsigned char *ptr;
+  dw_die_ref child;
+
+  if (die->die_offset == -1U)
+    return;
+
+  ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+  skip_leb128 (ptr);
+  for (i = 0; i < t->nattr; ++i)
+    {
+      uint32_t form = t->attr[i].form;
+      uint64_t value;
+      dw_die_ref ref, reft;
+
+      while (form == DW_FORM_indirect)
+	form = read_uleb128 (ptr);
+
+      switch (form)
+	{
+	case DW_FORM_ref_addr:
+	  value = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+	  ptr += cu->cu_version == 2 ? ptr_size : 4;
+	  ref = off_htab_lookup (cu, value);
+	  goto finish_ref;
+	  break;
+	case DW_FORM_ref_udata:
+	case DW_FORM_ref1:
+	case DW_FORM_ref2:
+	case DW_FORM_ref4:
+	case DW_FORM_ref8:
+	  switch (form)
+	    {
+	    case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+	    case DW_FORM_ref1: value = read_8 (ptr); break;
+	    case DW_FORM_ref2: value = read_16 (ptr); break;
+	    case DW_FORM_ref4: value = read_32 (ptr); break;
+	    case DW_FORM_ref8: value = read_64 (ptr); break;
+	    default: abort ();
+	    }
+	  if (t->attr[i].attr == DW_AT_sibling)
+	    break;
+	  ref = off_htab_lookup (cu, cu->cu_offset + value);
+	finish_ref:
+	  reft = ref;
+	  while (!reft->die_root
+		 && reft->die_parent->die_tag != DW_TAG_compile_unit
+		 && reft->die_parent->die_tag != DW_TAG_partial_unit
+		 && !reft->die_parent->die_named_namespace)
+	    reft = reft->die_parent;
+	  if (reft->die_root)
+	    ;
+	  else if (reft->die_ck_state == CK_KNOWN
+		   && !top_die->die_no_multifile && reft->die_no_multifile)
+	    {
+	      top_die->die_no_multifile = 1;
+	      *changed = true;
+	    }
+	  break;
+	default:
+	  ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+	}
+    }
+
+  for (child = die->die_child; child; child = child->die_sib)
+    propagate_multifile_refs_backward (cu, top_die, child, changed);
+}
+
+/* Do propagation of the die_no_multifile property that was not covered in
+   checksum_die and checksum_ref_die.  */
+static void
+propagate_multifile (void)
+{
+  bool changed;
+  dw_cu_ref cu;
+  dw_die_ref die;
+
+  changed = false;
+
+  FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+    propagate_multifile_duplicate_chain (die, &changed);
+
+  if (!changed)
+    return;
+
+  do
+    {
+      changed = false;
+
+      FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+	propagate_multifile_refs_backward (cu, die, die, &changed);
+
+      FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+	propagate_multifile_duplicate_chain (die, &changed);
+    }
+  while (changed);
+}
+
+/* Returns true if DIE contains any toplevel children that can be
+   potentially shared between different executables or shared libraries.  */
+static bool
+check_multifile (dw_die_ref die)
+{
+  dw_die_ref child;
+
+  die->die_no_multifile = 1;
+  for (child = die->die_child; child; child = child->die_sib)
+    if (child->die_named_namespace)
+      {
+	if (check_multifile (child))
+	  die->die_no_multifile = 0;
+      }
+    else if (child->die_offset == -1U)
+      {
+	if (child->die_nextdup && child->die_nextdup->die_dup == child)
+	  {
+	    if (child->die_nextdup->die_ck_state == CK_KNOWN
+		&& child->die_nextdup->die_no_multifile == 0)
+	      {
+		child->die_no_multifile = 0;
+		die->die_no_multifile = 0;
+	      }
+	    else
+	      child->die_no_multifile = 1;
+	  }
+	else
+	  child->die_no_multifile = 1;
+      }
+    else
+      {
+	child->die_op_type_referenced = 0;
+	if (child->die_dup == NULL
+	    && child->die_ck_state == CK_KNOWN
+	    && child->die_no_multifile == 0)
+	  die->die_no_multifile = 0;
+	else
+	  child->die_no_multifile = 1;
+      }
+  return die->die_no_multifile == 0;
+}
+
+/* Helper function for write_multifile_strp to sort strp_entry
+   by increasing new_off.  */
+static int
+strp_off_cmp (const void *p, const void *q)
+{
+  struct strp_entry *s1 = *(struct strp_entry **)p;
+  struct strp_entry *s2 = *(struct strp_entry **)q;
+  if (s1->new_off < s2->new_off)
+    return -1;
+  if (s1->new_off > s2->new_off)
+    return 1;
+  return 0;
+}
+
+/* Write tail optimized strings into the temporary .debug_str file.  */
+static int
+write_multifile_strp (void)
+{
+  unsigned int count = htab_elements (strp_htab), i, buf_alloc, buf_size;
+  struct strp_entry **arr = (struct strp_entry **)
+			    obstack_alloc (&ob, count * sizeof (*arr));
+  struct strp_entry **end = arr;
+  unsigned char *buf;
+  int ret = 0;
+
+  htab_traverse (strp_htab, list_strp_entries, (void *) &end);
+  assert (arr + count == end);
+  qsort (arr, count, sizeof (struct strp_entry *), strp_off_cmp);
+  buf_alloc = max_strp_off - debug_sections[DEBUG_STR].size;
+  if (buf_alloc > 131072)
+    buf_alloc = 131072;
+  buf = (unsigned char *) obstack_alloc (&ob, buf_alloc);
+  buf_size = 0;
+  for (i = 0; i < count; i++)
+    {
+      unsigned char *p = debug_sections[DEBUG_STR].data + arr[i]->off;
+      unsigned int len = strlen ((char *) p) + 1;
+      if (buf_alloc - buf_size < len)
+	{
+	  if (buf_size
+	      && write (multi_str_fd, buf, buf_size) != (ssize_t) buf_size)
+	    {
+	      ret = 1;
+	      break;
+	    }
+	  buf_size = 0;
+	  if (buf_alloc < len)
+	    {
+	      if (write (multi_str_fd, p, len) != (ssize_t) len)
+		{
+		  ret = 1;
+		  break;
+		}
+	      continue;
+	    }
+	}
+      memcpy (buf + buf_size, p, len);
+      buf_size += len;
+    }
+  if (buf_size
+      && ret == 0
+      && write (multi_str_fd, buf, buf_size) != (ssize_t) buf_size)
+    ret = 1;
+  obstack_free (&ob, (void *) arr);
+  return ret;
+}
+
+/* Hold some statistics on the line entries so we know whether to emit
+   time and/or sizes.  Used by list_line_entries used by
+   write_multifile_line.  */
+struct line_stats
+{
+  struct line_entry ***end;
+  bool has_time;
+  bool has_size;
+};
+
+/* Helper to find the end of the line_htab entries and other stats.
+   Called through htab_traverse.  */
+static int
+list_line_entries (void **slot, void *data)
+{
+  struct line_stats *stats = (struct line_stats *) data;
+  struct line_entry *entry = (struct line_entry *) *slot;
+  struct line_entry ***end = stats->end;
+  **end = entry;
+  (*end)++;
+  if (entry->file->time != 0)
+    stats->has_time = true;
+  if (entry->file->size != 0)
+    stats->has_size = true;
+  return 1;
+}
+
+/* Helper function for write_multifile_strp to sort line_entry
+   by increasing new_id.  */
+static int
+line_id_cmp (const void *p, const void *q)
+{
+  struct line_entry *s1 = *(struct line_entry **)p;
+  struct line_entry *s2 = *(struct line_entry **)q;
+  if (s1->new_id < s2->new_id)
+    return -1;
+  if (s1->new_id > s2->new_id)
+    return 1;
+  return 0;
+}
+
+/* Write a minimal .debug_line entry.  If not op_multifile, write it
+   into the temporary .debug_line file (if line_htab is non-NULL, fill
+   its directory and file table from it, otherwise emit an entry
+   with no directories or files), if op_multifile, store the entry
+   into debug_sections[DEBUG_LINE].new_data which it allocates.  */
+static int
+write_multifile_line (void)
+{
+  unsigned int filecnt = 0, dircnt = 0, filetbllen = 0, dirtbllen = 0;
+  unsigned int header_len, len, i, j;
+  unsigned char *line, *ptr;
+  struct line_entry **filearr = NULL;
+  struct line_stats line_stats;
+  unsigned int *diridx = NULL, *dirarr = NULL;
+  unsigned char buf[45]; /* Max header_len, see below.  */
+  int ret = 0;
+
+  line_stats.has_time = line_stats.has_size = false;
+  if (line_htab)
+    {
+      struct line_entry **end;
+      filecnt = htab_elements (line_htab);
+      filearr = (struct line_entry **)
+		obstack_alloc (&ob, filecnt * sizeof (*filearr));
+      end = filearr;
+      line_stats.end = &end;
+      htab_traverse (line_htab, list_line_entries, (void *) &line_stats);
+      assert (filearr + filecnt == end);
+      diridx = (unsigned int *)
+	       obstack_alloc (&ob, filecnt * sizeof (*diridx));
+      qsort (filearr, filecnt, sizeof (struct line_entry *), line_id_cmp);
+      for (i = 0; i < filecnt; i++)
+	{
+	  unsigned int direntrylen = 0;
+	  const char *file = filearr[i]->file->file;
+	  if (filearr[i]->file->dir == NULL)
+	    {
+	      const char *r = strrchr (file, '/'), *s;
+
+	      j = 0;
+	      direntrylen = r ? r - file : 0;
+	      while (direntrylen && file[direntrylen - 1] == '/')
+		direntrylen--;
+	      if (direntrylen)
+		{
+		  direntrylen++;
+		  for (j = 0; j < dircnt; j++)
+		    if (filearr[dirarr[j]]->file->dir == NULL
+			&& strncmp (filearr[dirarr[j]]->file->file,
+				    file, direntrylen) == 0)
+		      {
+			s = filearr[dirarr[j]]->file->file + direntrylen;
+			while (*s == '/')
+			  s++;
+			if (strchr (s, '/'))
+			  continue;
+			break;
+		      }
+		  j++;
+		  file = r + 1;
+		}
+	    }
+	  else
+	    {
+	      for (j = 0; j < dircnt; j++)
+		if (filearr[dirarr[j]]->file->dir
+		    && strcmp (filearr[dirarr[j]]->file->dir,
+			       filearr[i]->file->dir) == 0)
+		  break;
+	      j++;
+	      direntrylen = strlen (filearr[i]->file->dir) + 1;
+	    }
+	  if (j <= dircnt)
+	    diridx[i] = j;
+	  else
+	    {
+	      obstack_int_grow (&ob, i);
+	      diridx[i] = ++dircnt;
+	      dirarr = (unsigned int *) obstack_base (&ob);
+	      dirtbllen += direntrylen;
+	    }
+	  filetbllen += strlen (file) + 1;
+	  filetbllen += size_of_uleb128 (diridx[i]);
+	  if (lowest_line_version < 5 || line_stats.has_time)
+	    filetbllen += size_of_uleb128 (filearr[i]->file->time);
+	  if (lowest_line_version < 5 || line_stats.has_size)
+	    filetbllen += size_of_uleb128 (filearr[i]->file->size);
+	}
+      dirarr = (unsigned int *) obstack_finish (&ob);
+    }
+
+  /* standard .debug_line "header" length (both version 2 and 5):
+     unit_length (4) + version (2) + header_length (4) +
+     min_instr_length (1) + default_is_stmt (1) + line_base (1) +
+     line_range (1) + opcode_base (1) = 15
+
+     version 2 adds 2 bytes, one zero byte to terminate dir and file lists.
+
+     version 5 adds at least 11 bytes, max_ops_per_instr (1) +
+     address_size (1) + segment_size (1) + dir_entry_format_cnt (1) +
+     format_pair (2), file_entry_format_cnt (1) + file_format_pairs
+     (4). Plus dircnt (uleb128) + format_pair (2) if has_time +
+     format_pair (2) if has_size) + filecnt (uleb128).
+
+     version 5 also has 2 extra 6 byte "<dwz>" string entries for dir
+     and file entry zero, plus one for the zero file entry dir idx.
+  */
+  header_len = 15;
+  if (lowest_line_version < 5)
+    header_len += 2;
+  else
+    {
+      header_len += 11;
+      header_len += size_of_uleb128 (dircnt + 1);
+      header_len += size_of_uleb128 (filecnt + 1);
+      if (line_stats.has_time)
+	header_len += 2;
+      if (line_stats.has_size)
+	header_len += 2;
+      header_len += 2 * 6 + 1;
+    }
+  len = header_len + filetbllen + dirtbllen;
+  if (unlikely (op_multifile))
+    {
+      debug_sections[DEBUG_LINE].new_size = len;
+      debug_sections[DEBUG_LINE].new_data = malloc (len);
+      if (debug_sections[DEBUG_LINE].new_data == NULL)
+	dwz_oom ();
+      line = debug_sections[DEBUG_LINE].new_data;
+    }
+  else
+    {
+      if (multi_line_off + len < multi_line_off)
+	{
+	  if (line_htab)
+	    obstack_free (&ob, (void *) filearr);
+	  return 1;
+	}
+
+      if (len == header_len)
+	{
+	  line = buf;
+	  assert (sizeof (buf) >= header_len);
+	}
+      else
+	line = (unsigned char *) obstack_alloc (&ob, len);
+    }
+  ptr = line;
+  write_32 (ptr, len - 4);	/* Total length.  */
+  if (lowest_line_version < 5)
+    write_16 (ptr, 2);		/* DWARF version.  */
+  else
+    {
+      write_16 (ptr, 5);	/* DWARF version.  */
+      write_8 (ptr, multi_ptr_size);	/* Address size.  */
+      write_8 (ptr, 0);	       	/* Segment size.  */
+    }
+  write_32 (ptr,		/* Header length.  */
+	    len - (lowest_line_version < 5 ? 10 : 12));
+  write_8 (ptr, 1);		/* Minimum insn length.  */
+  if (lowest_line_version >= 5)
+    write_8 (ptr, 1);		/* Maximum ops per instr.  */
+  write_8 (ptr, 1);		/* Default is_stmt.  */
+  write_8 (ptr, 0);		/* Line base.  */
+  write_8 (ptr, 1);		/* Line range.  */
+  write_8 (ptr, 1);		/* Opcode base.  */
+
+  if (lowest_line_version >= 5)
+    {
+      write_8 (ptr, 1);		/* Dir entry format count.  */
+      write_uleb128 (ptr, DW_LNCT_path);
+      write_uleb128 (ptr, DW_FORM_string);
+      write_uleb128 (ptr, dircnt + 1); /* Dir cnt.  */
+      memcpy (ptr, "<dwz>", 6);	/* Zero entry empty dir path.  */
+      ptr += 6;
+    }
+
+  for (i = 0; i < dircnt; i++)
+    {
+      unsigned int l;
+      if (filearr[dirarr[i]]->file->dir)
+	{
+	  l = strlen (filearr[dirarr[i]]->file->dir) + 1;
+	  memcpy (ptr, filearr[dirarr[i]]->file->dir, l);
+	}
+      else
+	{
+	  const char *file = filearr[dirarr[i]]->file->file;
+	  const char *r = strrchr (file, '/');
+
+	  while (r && r > file && r[-1] == '/')
+	    r--;
+	  l = r - file + 1;
+	  memcpy (ptr, file, l - 1);
+	  ptr[l - 1] = '\0';
+	}
+      ptr += l;
+    }
+  if (lowest_line_version < 5)
+    write_8 (ptr, 0);		/* Terminate dir table.  */
+  else
+    {
+      unsigned int format_cnt = 2 + line_stats.has_size + line_stats.has_time;
+      write_8 (ptr, format_cnt);	/* File entry format count.  */
+      write_uleb128 (ptr, DW_LNCT_path);
+      write_uleb128 (ptr, DW_FORM_string);
+      write_uleb128 (ptr, DW_LNCT_directory_index);
+      write_uleb128 (ptr, DW_FORM_udata);
+      if (line_stats.has_time)
+	{
+	  write_uleb128 (ptr, DW_LNCT_timestamp);
+	  write_uleb128 (ptr, DW_FORM_udata);
+	}
+      if (line_stats.has_size)
+	{
+	  write_uleb128 (ptr, DW_LNCT_size);
+	  write_uleb128 (ptr, DW_FORM_udata);
+	}
+      write_uleb128 (ptr, filecnt + 1); /* File names cnt.  */
+      memcpy (ptr, "<dwz>", 6);		/* Zero entry empty file path.  */
+      ptr += 6;
+      write_8 (ptr, 0);	       		/* Zero entry zero diridx.  */
+      if (line_stats.has_time)
+	write_8 (ptr, 0);
+      if (line_stats.has_size)
+	write_8 (ptr, 0);
+    }
+
+  for (i = 0; i < filecnt; i++)
+    {
+      const char *file = filearr[i]->file->file;
+      unsigned int l;
+      if (diridx[i] && filearr[i]->file->dir == NULL)
+	file = strrchr (file, '/') + 1;
+      l = strlen (file) + 1;
+      memcpy (ptr, file, l);
+      ptr += l;
+      write_uleb128 (ptr, diridx[i]);
+      if (lowest_line_version < 5 || line_stats.has_time)
+	write_uleb128 (ptr, filearr[i]->file->time);
+      if (lowest_line_version < 5 || line_stats.has_size)
+	write_uleb128 (ptr, filearr[i]->file->size);
+    }
+  if (lowest_line_version < 5)
+    write_8 (ptr, 0);		/* Terminate file table.  */
+  assert (ptr == line + len);
+
+  if (likely (!op_multifile))
+    {
+      if (write (multi_line_fd, line, len) != (ssize_t) len)
+	ret = 1;
+      else
+	multi_line_off += len;
+      if (line_htab)
+	obstack_free (&ob, (void *) filearr);
+      else if (line != buf)
+	obstack_free (&ob, (void *) line);
+    }
+  else if (line_htab)
+    obstack_free (&ob, (void *) filearr);
+  return ret;
+}
+
+#if DEVEL
+/* In struct dw_die we have a union u with fields p1 and p2.  The p1 field is
+   used during phase 1, after which the space is reused for the p2 field
+   during phase 2.  Clear the p2 field to get rid of values stored to p1
+   during phase 1.  */
+static int
+clear_p2_field (void)
+{
+  dw_cu_ref cu;
+  dw_die_ref die;
+
+  FOREACH_DIE (cu, die)
+    {
+      assert (die->die_collapsed_child == 0);
+      die->u.p2.die_new_abbrev = NULL;
+      die->u.p2.die_new_offset = 0;
+      die->u.p2.die_intracu_udata_size = 0;
+    }
+
+  return 0;
+}
+#endif
+
+/* Helper structure for file state.  */
+struct file_result
+{
+  /* -3: Uninitialized.
+     -2: Already processed under different name.
+     -1: Ignore.
+      0: Processed, changed.
+      1: Processed, unchanged.  */
+  int res;
+  int ret;
+  size_t hardlink_to;
+  unsigned int die_count;
+  bool skip_multifile;
+  bool low_mem_p;
+};
+
+/* Collect potentially shareable DIEs, strings and .debug_macro
+   opcode sequences into temporary .debug_* files.  */
+static int
+write_multifile_1 (DSO *dso, struct file_result *res)
+{
+  dw_cu_ref cu;
+  bool any_cus = false;
+  unsigned int i;
+  int ret = 0;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "write_multifile\n");
+    }
+
+  if (multi_ehdr.e_ident[0] == '\0')
+    multi_ehdr = dso->ehdr;
+
+  if (multifile_force_ptr_size && ptr_size != multifile_force_ptr_size)
+    {
+      error (0, 0, "File %s skipped for multi-file optimization, different"
+	     " pointer size", dso->filename);
+      res->skip_multifile = true;
+      return 1;
+    }
+  else if (multi_ptr_size == 0)
+    multi_ptr_size = ptr_size;
+  else if (ptr_size != multi_ptr_size)
+    {
+      error (0, 0, "Multi-file optimization not allowed for different"
+	     " pointer sizes");
+      multifile = NULL;
+      return 1;
+    }
+  else
+    {
+      /* Same ptr_size.  */
+    }
+
+  int endianity = (do_read_32 == buf_read_ule32
+		   ? ELFDATA2LSB
+		   : ELFDATA2MSB);
+  if (multifile_force_endian && endianity != multifile_force_endian)
+    {
+      error (0, 0, "File %s skipped for multi-file optimization, different"
+	     " endianity", dso->filename);
+      res->skip_multifile = true;
+      return 1;
+    }
+  else if (multi_endian == 0)
+    multi_endian = endianity;
+  else if (multi_endian != endianity)
+    {
+      error (0, 0, "Multi-file optimization not allowed for different"
+	     " endianity");
+      multifile = NULL;
+      return 1;
+    }
+  else
+    {
+      /* Same endianity.  */
+    }
+
+#if DEVEL
+  clear_p2_field ();
+#endif
+
+  for (i = 0; i < SAVED_SECTIONS; i++)
+    {
+      saved_new_data[i] = debug_sections[i].new_data;
+      saved_new_size[i] = debug_sections[i].new_size;
+      debug_sections[i].new_data = NULL;
+      debug_sections[i].new_size = debug_sections[i].size;
+    }
+  propagate_multifile ();
+  for (cu = first_cu; cu && cu->cu_kind != CU_TYPES; cu = cu->cu_next)
+    {
+      cu->u1.cu_new_abbrev_owner = NULL;
+      cu->u2.cu_new_abbrev_offset = 0;
+      cu->cu_new_offset = 0;
+      any_cus |= check_multifile (cu->cu_die);
+    }
+  if (any_cus)
+    {
+      dw_cu_ref *cup;
+
+      for (cup = &first_cu; *cup && (*cup)->cu_kind != CU_TYPES; )
+	{
+	  if ((*cup)->cu_new_abbrev)
+	    htab_delete ((*cup)->cu_new_abbrev);
+
+	  if ((*cup)->cu_die->die_no_multifile == 0)
+	    cup = &(*cup)->cu_next;
+	  else
+	    *cup = (*cup)->cu_next;
+	}
+      *cup = NULL;
+      multifile_mode = MULTIFILE_MODE_WR;
+      if (tracing)
+	fprintf (stderr, "Write-multifile %s\n", dso->filename);
+      if (compute_abbrevs (NULL))
+	ret = 1;
+      else if (debug_sections[DEBUG_MACRO].data && read_macro (dso))
+	ret = 1;
+      else if ((unsigned int) (multi_info_off
+			       + debug_sections[DEBUG_INFO].new_size)
+	       < multi_info_off
+	       || (unsigned int) (multi_abbrev_off
+				  + debug_sections[DEBUG_ABBREV].new_size)
+		  < multi_abbrev_off
+	       || (unsigned int) (multi_str_off
+				  + (max_strp_off ? max_strp_off
+				     : debug_sections[DEBUG_ABBREV].size))
+		  < multi_str_off
+	       || (unsigned int) (multi_macro_off
+				  + debug_sections[DEBUG_MACRO].new_size)
+		  < multi_macro_off)
+	{
+	  error (0, 0, "Multifile temporary files too large");
+	  multifile = NULL;
+	  ret = 1;
+	}
+      else
+	{
+	  const char *mfile;
+	  write_abbrev ();
+	  write_info (NULL);
+	  /* Any error in this is fatal for multifile handling of further
+	     files.  */
+	  mfile = multifile;
+	  multifile = NULL;
+	  if (write (multi_abbrev_fd, debug_sections[DEBUG_ABBREV].new_data,
+		     debug_sections[DEBUG_ABBREV].new_size)
+	      != (ssize_t) debug_sections[DEBUG_ABBREV].new_size
+	      || write (multi_info_fd, debug_sections[DEBUG_INFO].new_data,
+			debug_sections[DEBUG_INFO].new_size)
+		 != (ssize_t) debug_sections[DEBUG_INFO].new_size
+	      || write (multi_str_fd, debug_sections[DEBUG_STR].data,
+			debug_sections[DEBUG_STR].size)
+		 != (ssize_t) debug_sections[DEBUG_STR].size
+	      || (debug_sections[DEBUG_MACRO].new_data
+		  && write (multi_macro_fd,
+			    debug_sections[DEBUG_MACRO].new_data,
+			    debug_sections[DEBUG_MACRO].new_size)
+		     != (ssize_t) debug_sections[DEBUG_MACRO].new_size)
+	      || (strp_htab != NULL && write_multifile_strp ())
+	      || write_multifile_line ())
+	    {
+	      error (0, 0, "Error writing multi-file temporary files");
+	      ret = 1;
+	    }
+	  else
+	    {
+	      multi_info_off += debug_sections[DEBUG_INFO].new_size;
+	      multi_abbrev_off += debug_sections[DEBUG_ABBREV].new_size;
+	      multi_str_off += max_strp_off ? max_strp_off
+			       : debug_sections[DEBUG_STR].size;
+	      multi_macro_off += debug_sections[DEBUG_MACRO].new_size;
+	      multifile = mfile;
+	    }
+	}
+    }
+  multifile_mode = 0;
+  for (i = 0; i < SAVED_SECTIONS; i++)
+    {
+      free (debug_sections[i].new_data);
+      debug_sections[i].new_data = saved_new_data[i];
+      debug_sections[i].new_size = saved_new_size[i];
+      saved_new_data[i] = NULL;
+    }
+  return ret;
+}
+
+struct pipe
+{
+  int readfd;
+  int writefd;
+};
+
+static bool write_multifile_parallel_p;
+static int child_id;
+static struct pipe *pipes;
+
+/* Get token.  */
+static void
+get_token (void)
+{
+  int n = child_id;
+  int readfd = pipes[n].readfd;
+  int writefd = pipes[n].writefd;
+  close (writefd);
+  char buf;
+  read (readfd, &buf, 1);
+  close (readfd);
+}
+
+/* Pass token to child N.  */
+static void
+pass_token (int n)
+{
+  int readfd = pipes[n].readfd;
+  int writefd = pipes[n].writefd;
+  close (readfd);
+  char buf = '\0';
+  write (writefd, &buf, 1);
+  close (writefd);
+}
+
+/* Wrapper around write_multifile_1 that ensures write_multifile_1 is called
+   in file order.  */
+static int
+write_multifile (DSO *dso, struct file_result *res)
+{
+  int ret;
+
+  if (write_multifile_parallel_p)
+    {
+      get_token ();
+
+      multi_info_off = lseek (multi_info_fd, 0L, SEEK_END);
+      multi_abbrev_off = lseek (multi_abbrev_fd, 0L, SEEK_END);
+      multi_line_off = lseek (multi_line_fd, 0L, SEEK_END);
+      multi_str_off = lseek (multi_str_fd, 0L, SEEK_END);
+      multi_macro_off = lseek (multi_macro_fd, 0L, SEEK_END);
+    }
+
+  ret = write_multifile_1 (dso, res);
+
+  return ret;
+}
+
+/* During fi_multifile phase, see what DIEs in a partial unit
+   contain no children worth keeping where all real DIEs have
+   dups in the shared .debug_info section and what remains is
+   just the DW_TAG_partial_unit, a single DW_TAG_imported_unit
+   and perhaps some empty named namespaces.  Then all the
+   references to that partial unit can be replaced by references
+   to the shared partial unit DW_TAG_import_unit has been importing.  */
+static bool
+remove_empty_pu (dw_die_ref die)
+{
+  dw_die_ref child = die->die_child, dup = NULL;
+  if (!die->die_named_namespace)
+    {
+      if (die->die_tag != DW_TAG_partial_unit
+	  || child == NULL
+	  || child->die_tag != DW_TAG_imported_unit
+	  || child->die_offset != -1U)
+	return false;
+      if (die->die_abbrev->nattr > 2)
+	return false;
+      if (die->die_abbrev->nattr
+	  && die->die_abbrev->attr[0].attr != DW_AT_stmt_list)
+	return false;
+      if (die->die_abbrev->nattr == 2
+	  && die->die_abbrev->attr[1].attr != DW_AT_comp_dir)
+	return false;
+      dup = child->die_nextdup;
+      child = child->die_sib;
+    }
+  else
+    {
+      if (die->die_abbrev->nattr > 2)
+	return false;
+      if (die->die_abbrev->nattr
+	  && die->die_abbrev->attr[0].attr != DW_AT_name)
+	return false;
+      if (die->die_abbrev->nattr == 2
+	  && die->die_abbrev->attr[1].attr != DW_AT_sibling)
+	return false;
+    }
+  for (; child; child = child->die_sib)
+    if (!child->die_named_namespace)
+      {
+	if (!child->die_remove)
+	  /* Signal that DIE can't be removed, but
+	     perhaps we could still remove_empty_pu
+	     some named namespaces that are children of DIE.  */
+	  dup = die;
+	if (dup == NULL && die->die_named_namespace)
+	  dup = child->die_dup->die_parent;
+      }
+    else if (!remove_empty_pu (child))
+      return false;
+    else if (dup == NULL && die->die_named_namespace)
+      dup = child->die_dup->die_parent;
+  if (dup == NULL || dup == die)
+    return false;
+  die->die_remove = 1;
+  assert (dup->die_tag == die->die_tag);
+  die->die_dup = dup;
+  return true;
+}
+
+/* Call remove_empty_pu on all partial units.  */
+static int
+remove_empty_pus (void)
+{
+  dw_cu_ref cu;
+  for (cu = first_cu; cu; cu = cu->cu_next)
+    if (cu->cu_kind == CU_NORMAL
+	&& cu->cu_die->die_tag == DW_TAG_partial_unit)
+      remove_empty_pu (cu->cu_die);
+  return 0;
+}
+
+/* Handle compression of a single file FILE.  If OUTFILE is
+   non-NULL, the result will be stored into that file, otherwise
+   the result will be written into a temporary file that is renamed
+   over FILE.  */
+static int
+dwz (const char *file, const char *outfile, struct file_result *res)
+{
+  DSO *dso;
+  int ret = 0, fd;
+  unsigned int i;
+  struct stat st;
+
+  if (res->res == -1)
+    return 1;
+
+  res->res = -1;
+  fd = open (file, O_RDONLY);
+  if (fd < 0)
+    {
+      error (0, errno, "Failed to open input file %s", file);
+      return 1;
+    }
+  if (fstat (fd, &st) < 0)
+    {
+      close (fd);
+      error (0, errno, "Failed to stat input file %s", file);
+      return 1;
+    }
+
+  res->res = 1;
+
+  if (tracing)
+    {
+      fprintf (stderr, "Compressing %s", file);
+      if (multifile_mode == 0)
+	;
+      else if (low_mem)
+	fprintf (stderr, " in low-mem mode");
+      else if (fi_multifile)
+	fprintf (stderr, " in finalize-multifile mode");
+      else
+	abort ();
+      fprintf (stderr, "\n");
+    }
+
+  dso = fdopen_dso (fd, file);
+  if (dso == NULL)
+    return 1;
+
+  obstack_alloc_failed_handler = dwz_oom;
+  if (setjmp (oom_buf))
+    {
+      error (0, ENOMEM, "%s: Could not allocate memory", dso->filename);
+
+      cleanup ();
+      ret = 1;
+    }
+  else
+    {
+      obstack_init (&ob);
+      obstack_init (&ob2);
+
+      unsigned int *die_count = multifile ? &res->die_count : NULL;
+      ret = read_dwarf (dso, quiet && outfile == NULL, die_count);
+      if (ret)
+	cleanup ();
+      else if (partition_dups ()
+	       || create_import_tree ()
+	       || (unlikely (fi_multifile)
+		   && (remove_empty_pus ()
+		       || read_macro (dso)))
+	       || read_debug_info (dso, DEBUG_TYPES, NULL)
+#if DEVEL
+	       || clear_p2_field ()
+#endif
+	       || compute_abbrevs (dso)
+	       || (unlikely (fi_multifile) && (finalize_strp (false), 0)))
+	{
+	  cleanup ();
+	  ret = 1;
+	}
+      else if (!(ignore_size || force_p)
+	       && ((debug_sections[DEBUG_INFO].new_size
+		    + debug_sections[DEBUG_ABBREV].new_size
+		    + debug_sections[DEBUG_STR].new_size
+		    + debug_sections[DEBUG_MACRO].new_size
+		    + debug_sections[DEBUG_TYPES].new_size)
+		   >= (debug_sections[DEBUG_INFO].size
+		       + debug_sections[DEBUG_ABBREV].size
+		       + debug_sections[DEBUG_STR].size
+		       + debug_sections[DEBUG_MACRO].size
+		       + debug_sections[DEBUG_TYPES].size)))
+	{
+	  if (!quiet || outfile != NULL)
+	    error (0, 0, "%s: DWARF compression not beneficial "
+			 "- old size %ld new size %ld", dso->filename,
+		   (unsigned long) (debug_sections[DEBUG_INFO].size
+				    + debug_sections[DEBUG_ABBREV].size
+				    + debug_sections[DEBUG_STR].size
+				    + debug_sections[DEBUG_MACRO].size
+				    + debug_sections[DEBUG_TYPES].size),
+		   (unsigned long) (debug_sections[DEBUG_INFO].new_size
+				    + debug_sections[DEBUG_ABBREV].new_size
+				    + debug_sections[DEBUG_STR].new_size
+				    + debug_sections[DEBUG_MACRO].new_size
+				    + debug_sections[DEBUG_TYPES].new_size));
+
+	  if (multifile && !fi_multifile && !low_mem)
+	    write_multifile (dso, res);
+
+	  cleanup ();
+	  if (outfile != NULL)
+	    ret = 1;
+	}
+      else if (write_aranges (dso))
+	{
+	failure:
+	  cleanup ();
+	  ret = 1;
+	}
+      else
+	{
+	  if (unlikely (fi_multifile))
+	    {
+	      size_t len;
+	      const char *name = multifile_name;
+	      enum debug_section_kind sec_kind;
+	      unsigned char *ptr;
+	      if (multifile_name == NULL)
+		{
+		  if (!multifile_relative)
+		    name = multifile;
+		  else
+		    {
+		      char *p1 = realpath (file, NULL);
+		      char *p2 = realpath (multifile, NULL);
+		      char *p3, *p4, *p5, *p6;
+		      unsigned int dotdot = 0;
+		      if (p1 == NULL || p2 == NULL)
+			{
+			  if (p1)
+			    free (p1);
+			  else if (p2)
+			    free (p2);
+			  error (0, 0, "Could not compute relative multifile "
+				       "pathname from %s to %s",
+				 file, multifile);
+			  goto failure;
+			}
+		      p3 = p1;
+		      p4 = p2;
+		      do
+			{
+			  p5 = strchr (p3, '/');
+			  p6 = strchr (p4, '/');
+			  if (p5 == NULL
+			      || p6 == NULL
+			      || p5 - p3 != p6 - p4
+			      || memcmp (p3, p4, p5 - p3) != 0)
+			    break;
+			  p3 = p5 + 1;
+			  p4 = p6 + 1;
+			}
+		      while (1);
+		      while (p5 != NULL)
+			{
+			  dotdot++;
+			  p5 = strchr (p5 + 1, '/');
+			}
+		      len = strlen (p4);
+		      p3 = (char *) malloc (dotdot * 3 + len + 1);
+		      if (p3 == NULL)
+			dwz_oom ();
+		      p5 = p3;
+		      while (dotdot)
+			{
+			  memcpy (p5, "../", 3);
+			  p5 += 3;
+			  dotdot--;
+			}
+		      memcpy (p5, p4, len + 1);
+		      free (p1);
+		      free (p2);
+		      name = p3;
+		    }
+		}
+	      len = strlen (name) + 1;
+	      sec_kind = dwarf_5 ? DEBUG_SUP : GNU_DEBUGALTLINK;
+	      debug_sections[sec_kind].new_size
+		= len + 0x14 + (dwarf_5 ? 4 : 0);
+	      debug_sections[sec_kind].new_data
+		= malloc (debug_sections[sec_kind].new_size);
+	      if (debug_sections[sec_kind].new_data == NULL)
+		dwz_oom ();
+	      ptr = debug_sections[sec_kind].new_data;
+	      if (dwarf_5)
+		{
+		  write_16 (ptr, 5);
+		  write_8 (ptr, 0);
+		}
+	      memcpy (ptr, name, len);
+	      ptr += len;
+	      if (dwarf_5)
+		write_uleb128 (ptr, 0x14);
+	      memcpy (ptr, multifile_sha1, 0x14);
+	      if (name != multifile_name && name != multifile)
+		free ((void *) name);
+	      write_macro ();
+	    }
+	  write_abbrev ();
+	  write_info (die_count);
+	  if (unlikely (progress_p))
+	    {
+	      report_progress ();
+	      fprintf (stderr, "write_loc\n");
+	    }
+	  write_loc ();
+	  if (unlikely (progress_p))
+	    {
+	      report_progress ();
+	      fprintf (stderr, "write_loclists\n");
+	    }
+	  write_loclists ();
+	  if (unlikely (progress_p))
+	    {
+	      report_progress ();
+	      fprintf (stderr, "write_types\n");
+	    }
+	  write_types ();
+	  if (unlikely (progress_p))
+	    {
+	      report_progress ();
+	      fprintf (stderr, "write_gdb_index\n");
+	    }
+	  write_gdb_index ();
+	  /* These sections are optional and it is unclear
+	     how to adjust them.  Just remove them.  */
+	  debug_sections[DEBUG_PUBNAMES].new_data = NULL;
+	  debug_sections[DEBUG_PUBNAMES].new_size = 0;
+	  debug_sections[DEBUG_PUBTYPES].new_data = NULL;
+	  debug_sections[DEBUG_PUBTYPES].new_size = 0;
+	  debug_sections[DEBUG_GNU_PUBNAMES].new_data = NULL;
+	  debug_sections[DEBUG_GNU_PUBNAMES].new_size = 0;
+	  debug_sections[DEBUG_GNU_PUBTYPES].new_data = NULL;
+	  debug_sections[DEBUG_GNU_PUBTYPES].new_size = 0;
+
+	  if (multifile && !fi_multifile && !low_mem)
+	    write_multifile (dso, res);
+
+	  bool save_to_temp = save_temps && multifile && multifile_mode == 0;
+	  cleanup ();
+
+	  if (write_dso (dso, outfile, &st, save_to_temp))
+	    ret = 1;
+	  else
+	    res->res = 0;
+
+	  if (unlikely (progress_p))
+	    report_progress ();
+	}
+    }
+
+  for (i = 0; debug_sections[i].name; ++i)
+    {
+      debug_sections[i].data = NULL;
+      debug_sections[i].size = 0;
+      free (debug_sections[i].new_data);
+      debug_sections[i].new_data = NULL;
+      debug_sections[i].new_size = 0;
+      debug_sections[i].sec = 0;
+    }
+
+  if (elf_end (dso->elf) < 0)
+    {
+      error (0, 0, "elf_end failed: %s", elf_errmsg (elf_errno ()));
+      ret = 1;
+    }
+  close (fd);
+
+  free (dso);
+  if (ret == 3)
+    {
+      ret = (outfile != NULL) ? 1 : 0;
+      res->res = -1;
+    }
+  return ret;
+}
+
+/* In order to free all malloced memory at the end of optimize_multifile,
+   communicate .debug_str tail optimized offset list from optimize_multifile
+   to read_multifile using an mmapped chunk of memory pointed by this
+   variable.  */
+static unsigned int *strp_tail_off_list;
+
+/* Process temporary .debug_* files, see what can be beneficially shared
+   and write a new ET_REL file, containing the shared .debug_* sections.  */
+static int
+optimize_multifile (unsigned int *die_count)
+{
+  DSO dsobuf, *dso;
+  int fd = -1;
+  volatile int vfd = -1;
+  unsigned int i;
+  Elf *elf = NULL;
+  Elf *volatile velf = NULL;
+  GElf_Shdr shdr;
+  Elf_Scn *scn;
+  Elf_Data *data;
+  char *e_ident;
+  static const char shstrtab_gnu[]
+    = "\0.shstrtab\0.note.gnu.build-id\0.gdb_index\0"
+      ".debug_info\0.debug_abbrev\0.debug_line\0.debug_str\0.debug_macro";
+  static const char shstrtab_dwarf5[]
+    = "\0.shstrtab\0.gdb_index\0"
+      ".debug_info\0.debug_abbrev\0.debug_line\0.debug_str\0.debug_macro\0"
+      ".debug_sup";
+  const char *const shstrtab = dwarf_5 ? shstrtab_dwarf5 : shstrtab_gnu;
+  const size_t shstrtab_len = (dwarf_5
+			       ? sizeof shstrtab_dwarf5
+			       : sizeof shstrtab_gnu);
+  const char *p;
+  unsigned char note[0x24], *np, *supp;
+  struct sha1_ctx ctx;
+
+  if (multi_ehdr.e_ident[0] == '\0'
+      || multi_ptr_size == 0
+      || multi_endian == 0)
+    return -1;
+
+  if (multi_line_off == 0)
+    {
+      init_endian (multi_endian);
+      if (write_multifile_line ())
+	{
+	  error (0, 0, "Error writing multi-file temporary files");
+	  return -1;
+	}
+    }
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "optimize_multifile\n");
+    }
+
+  debug_sections[DEBUG_INFO].size = multi_info_off;
+  debug_sections[DEBUG_INFO].data
+    = (multi_info_off
+       ? mmap (NULL, multi_info_off, PROT_READ, MAP_PRIVATE, multi_info_fd, 0)
+       : NULL);
+  debug_sections[DEBUG_ABBREV].size = multi_abbrev_off;
+  debug_sections[DEBUG_ABBREV].data
+    = (multi_abbrev_off
+       ? mmap (NULL, multi_abbrev_off, PROT_READ, MAP_PRIVATE,
+	       multi_abbrev_fd, 0)
+       : NULL);
+  debug_sections[DEBUG_LINE].size = multi_line_off;
+  debug_sections[DEBUG_LINE].data
+    = mmap (NULL, multi_line_off, PROT_READ, MAP_PRIVATE, multi_line_fd, 0);
+  debug_sections[DEBUG_STR].size = multi_str_off;
+  debug_sections[DEBUG_STR].data
+    = multi_str_off
+      ? mmap (NULL, multi_str_off, PROT_READ, MAP_PRIVATE, multi_str_fd, 0)
+      : NULL;
+  debug_sections[DEBUG_MACRO].size = multi_macro_off;
+  debug_sections[DEBUG_MACRO].data
+    = multi_macro_off
+      ? mmap (NULL, multi_macro_off, PROT_READ, MAP_PRIVATE, multi_macro_fd, 0)
+      : NULL;
+  if (debug_sections[DEBUG_INFO].data == MAP_FAILED
+      || debug_sections[DEBUG_ABBREV].data == MAP_FAILED
+      || debug_sections[DEBUG_LINE].data == MAP_FAILED
+      || debug_sections[DEBUG_STR].data == MAP_FAILED
+      || debug_sections[DEBUG_MACRO].data == MAP_FAILED)
+    {
+      error (0, 0, "Error mmapping multi-file temporary files");
+    fail:
+      cleanup ();
+      if (velf)
+	elf_end (velf);
+      if (vfd != -1)
+	{
+	  unlink (multifile);
+	  close (vfd);
+	}
+      if (debug_sections[DEBUG_INFO].data != MAP_FAILED)
+	munmap (debug_sections[DEBUG_INFO].data,
+		debug_sections[DEBUG_INFO].size);
+      if (debug_sections[DEBUG_ABBREV].data != MAP_FAILED)
+	munmap (debug_sections[DEBUG_ABBREV].data,
+		debug_sections[DEBUG_ABBREV].size);
+      if (debug_sections[DEBUG_LINE].data != MAP_FAILED)
+	munmap (debug_sections[DEBUG_LINE].data,
+		debug_sections[DEBUG_LINE].size);
+      if (debug_sections[DEBUG_STR].data != MAP_FAILED
+	  && debug_sections[DEBUG_STR].data != NULL)
+	munmap (debug_sections[DEBUG_STR].data,
+		debug_sections[DEBUG_STR].size);
+      if (debug_sections[DEBUG_MACRO].data != MAP_FAILED
+	  && debug_sections[DEBUG_MACRO].data != NULL)
+	munmap (debug_sections[DEBUG_MACRO].data,
+		debug_sections[DEBUG_MACRO].size);
+      return -1;
+    }
+
+  init_endian (multi_endian);
+  ptr_size = multi_ptr_size;
+  memset (&dsobuf, '\0', sizeof (dsobuf));
+  dso = &dsobuf;
+  dso->filename = multifile;
+  if (tracing)
+    fprintf (stderr, "Optimize-multifile\n");
+  multifile_mode = MULTIFILE_MODE_OP;
+
+  obstack_alloc_failed_handler = dwz_oom;
+  if (unoptimized_multifile)
+    {
+      for (i = 0; i < SAVED_SECTIONS; i++)
+	{
+	  debug_sections[i].new_data = debug_sections[i].data;
+	  debug_sections[i].new_size = debug_sections[i].size;
+	}
+    }
+  else if (setjmp (oom_buf))
+    {
+      error (0, ENOMEM, "%s: Could not allocate memory", dso->filename);
+      goto fail;
+    }
+  else
+    {
+      dw_cu_ref *cup;
+      unsigned char *p, *q;
+      unsigned int strp_count;
+
+      obstack_init (&ob);
+      obstack_init (&ob2);
+
+      if (read_debug_info (dso, DEBUG_INFO, NULL)
+	  || partition_dups ())
+	goto fail;
+
+#if DEVEL
+      clear_p2_field ();
+#endif
+
+      for (cup = &first_cu; *cup && (*cup)->cu_kind == CU_PU;
+	   cup = &(*cup)->cu_next)
+	;
+
+      *cup = NULL;
+
+      strp_count = debug_sections[DEBUG_STR].size / 64;
+      if (strp_count < 64)
+	strp_count = 64;
+      strp_htab = htab_try_create (strp_count,
+				   strp_hash2, strp_eq2, NULL);
+      if (strp_htab == NULL)
+	dwz_oom ();
+
+      for (p = debug_sections[DEBUG_STR].data;
+	   p < debug_sections[DEBUG_STR].data + debug_sections[DEBUG_STR].size;
+	   p = q + 1)
+	{
+	  void **slot;
+	  struct strp_entry se;
+	  hashval_t hash;
+
+	  q = (unsigned char *) strchr ((char *) p, '\0');
+	  hash = hash (p, q - p);
+	  se.off = p - debug_sections[DEBUG_STR].data;
+	  se.new_off = hash & ~1U;
+	  slot = htab_find_slot_with_hash (strp_htab, &se, se.new_off, INSERT);
+	  if (slot == NULL)
+	    dwz_oom ();
+	  if (*slot == NULL)
+	    {
+	      struct strp_entry *s = pool_alloc (strp_entry, sizeof (*s));
+	      *s = se;
+	      *slot = (void *) s;
+	    }
+	  else
+	    ((struct strp_entry *) *slot)->new_off |= 1;
+	}
+
+      if (first_cu != NULL)
+	{
+	  if (compute_abbrevs (dso))
+	    goto fail;
+
+	  strp_tail_off_list = finalize_strp (true);
+
+	  write_abbrev ();
+	  write_info (die_count);
+	  write_gdb_index ();
+	  if (write_multifile_line ())
+	    goto fail;
+	}
+      else
+	strp_tail_off_list = finalize_strp (true);
+
+      if (debug_sections[DEBUG_MACRO].data)
+	handle_macro ();
+    }
+
+  np = note;
+  write_32 (np, sizeof ("GNU"));
+  write_32 (np, 0x14);
+  write_32 (np, NT_GNU_BUILD_ID);
+
+  supp = NULL;
+  if (dwarf_5)
+    {
+      debug_sections[DEBUG_SUP].new_size = 0x14 + 5;
+      debug_sections[DEBUG_SUP].new_data
+	= malloc (debug_sections[DEBUG_SUP].new_size);
+      if (debug_sections[DEBUG_SUP].new_data == NULL)
+	dwz_oom ();
+      supp = debug_sections[DEBUG_SUP].new_data;
+      write_16 (supp, 5);
+      write_8 (supp, 1);
+      write_8 (supp, 0);
+      write_uleb128 (supp, 0x14);
+    }
+
+  cleanup ();
+  fd = open (multifile, O_RDWR | O_CREAT, 0600);
+  vfd = fd;
+  if (fd < 0)
+    {
+      error (0, errno, "Failed to open multi-file common file %s", multifile);
+      goto fail;
+    }
+
+  elf = elf_begin (fd, ELF_C_WRITE, NULL);
+  velf = elf;
+  if (elf == NULL)
+    {
+      error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1));
+      goto fail;
+    }
+
+  multi_ehdr.e_type = ET_REL;
+  multi_ehdr.e_entry = 0;
+  multi_ehdr.e_phoff = 0;
+  multi_ehdr.e_phnum = 0;
+  multi_ehdr.e_shoff = multi_ehdr.e_ehsize;
+  multi_ehdr.e_shnum = 2;
+  if (!dwarf_5)
+    {
+      multi_ehdr.e_shoff += 0x24;
+      multi_ehdr.e_shnum++;
+    }
+  for (i = 0; debug_sections[i].name; i++)
+    if (debug_sections[i].new_size)
+      {
+	multi_ehdr.e_shoff += debug_sections[i].new_size;
+	multi_ehdr.e_shnum++;
+      }
+  multi_ehdr.e_shstrndx = multi_ehdr.e_shnum - 1;
+
+  /* Some gelf_newehdr implementations don't return the resulting
+     ElfNN_Ehdr, so we have to do it the hard way instead of:
+     e_ident = (char *) gelf_newehdr (elf, gelf_getclass (dso->elf));  */
+  switch (multi_ehdr.e_ident[EI_CLASS])
+    {
+    case ELFCLASS32:
+      e_ident = (char *) elf32_newehdr (elf);
+      multi_ehdr.e_shoff = (multi_ehdr.e_shoff + 3) & -4;
+      break;
+    case ELFCLASS64:
+      e_ident = (char *) elf64_newehdr (elf);
+      multi_ehdr.e_shoff = (multi_ehdr.e_shoff + 7) & -8;
+      break;
+    default:
+      e_ident = NULL;
+      break;
+    }
+
+  if (e_ident == NULL
+      /* This is here just for the gelfx wrapper, so that gelf_update_ehdr
+	 already has the correct ELF class.  */
+      || memcpy (e_ident, multi_ehdr.e_ident, EI_NIDENT) == NULL
+      || gelf_update_ehdr (elf, &multi_ehdr) == 0)
+    {
+      error (0, 0, "Could not create new ELF headers");
+      goto fail;
+    }
+  elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT | ELF_F_PERMISSIVE);
+
+  sha1_init_ctx (&ctx);
+  for (i = 0; debug_sections[i].name; i++)
+    {
+      if (debug_sections[i].new_size == 0)
+	continue;
+      sha1_process_bytes (debug_sections[i].new_data,
+			  debug_sections[i].new_size, &ctx);
+    }
+  sha1_finish_ctx (&ctx, multifile_sha1);
+
+  memcpy (np, "GNU", sizeof ("GNU"));
+  memcpy (np + 4, multifile_sha1, 0x14);
+
+  if (dwarf_5)
+    memcpy (supp, multifile_sha1, 0x14);
+
+  memset (&shdr, '\0', sizeof (shdr));
+  shdr.sh_offset = multi_ehdr.e_ehsize;
+  if (!dwarf_5)
+    {
+      shdr.sh_type = SHT_NOTE;
+      shdr.sh_addralign = 4;
+      shdr.sh_size = 0x24;
+      scn = elf_newscn (elf);
+      elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+      shdr.sh_name = (strchr (shstrtab + 1, '\0') + 1) - shstrtab;
+      gelf_update_shdr (scn, &shdr);
+      data = elf_newdata (scn);
+      data->d_buf = (char *) note;
+      data->d_type = ELF_T_BYTE;
+      data->d_version = EV_CURRENT;
+      data->d_size = shdr.sh_size;
+      data->d_off = 0;
+      data->d_align = 1;
+    }
+
+  shdr.sh_type = SHT_PROGBITS;
+  shdr.sh_offset += shdr.sh_size;
+  shdr.sh_addralign = 1;
+  for (i = 0; debug_sections[i].name; i++)
+    {
+      if (debug_sections[i].new_size == 0)
+	continue;
+      scn = elf_newscn (elf);
+      elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+      for (p = shstrtab + 1; p < shstrtab + shstrtab_len;
+	   p = strchr (p, '\0') + 1)
+	if (strcmp (p, debug_sections[i].name) == 0)
+	  {
+	    shdr.sh_name = p - shstrtab;
+	    break;
+	  }
+      shdr.sh_size = debug_sections[i].new_size;
+      if (i == DEBUG_STR)
+	{
+	  shdr.sh_flags = SHF_MERGE | SHF_STRINGS;
+	  shdr.sh_entsize = 1;
+	}
+      else
+	{
+	  shdr.sh_flags = 0;
+	  shdr.sh_entsize = 0;
+	}
+      gelf_update_shdr (scn, &shdr);
+      data = elf_newdata (scn);
+      data->d_buf = debug_sections[i].new_data;
+      data->d_type = ELF_T_BYTE;
+      data->d_version = EV_CURRENT;
+      data->d_size = shdr.sh_size;
+      data->d_off = 0;
+      data->d_align = 1;
+      shdr.sh_offset += shdr.sh_size;
+    }
+  scn = elf_newscn (elf);
+  elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+  shdr.sh_name = 1;
+  shdr.sh_offset = multi_ehdr.e_shoff
+		   + multi_ehdr.e_shnum * multi_ehdr.e_shentsize;
+  shdr.sh_size = shstrtab_len;
+  shdr.sh_type = SHT_STRTAB;
+  shdr.sh_flags = 0;
+  shdr.sh_entsize = 0;
+  gelf_update_shdr (scn, &shdr);
+  data = elf_newdata (scn);
+  data->d_buf = (char *) shstrtab;
+  data->d_type = ELF_T_BYTE;
+  data->d_version = EV_CURRENT;
+  data->d_size = shdr.sh_size;
+  data->d_off = 0;
+  data->d_align = 1;
+
+  if (elf_update (elf, ELF_C_WRITE_MMAP) == -1)
+    {
+      error (0, 0, "%s: elf_update failed", multifile);
+      goto fail;
+    }
+
+  if (elf_end (elf) < 0)
+    {
+      error (0, 0, "elf_end failed: %s", elf_errmsg (elf_errno ()));
+      goto fail;
+    }
+
+  fchmod (fd, 0644);
+
+  if (dwarf_5)
+    {
+      free (debug_sections[DEBUG_SUP].new_data);
+      debug_sections[DEBUG_SUP].new_data = NULL;
+    }
+  munmap (debug_sections[DEBUG_INFO].data, debug_sections[DEBUG_INFO].size);
+  munmap (debug_sections[DEBUG_ABBREV].data,
+	  debug_sections[DEBUG_ABBREV].size);
+  munmap (debug_sections[DEBUG_LINE].data, debug_sections[DEBUG_LINE].size);
+  if (debug_sections[DEBUG_STR].data)
+    munmap (debug_sections[DEBUG_STR].data, debug_sections[DEBUG_STR].size);
+  if (debug_sections[DEBUG_MACRO].data)
+    munmap (debug_sections[DEBUG_MACRO].data,
+	    debug_sections[DEBUG_MACRO].size);
+
+  for (i = 0; debug_sections[i].name; ++i)
+    {
+      debug_sections[i].data = NULL;
+      debug_sections[i].size = 0;
+      if (!unoptimized_multifile)
+	free (debug_sections[i].new_data);
+      debug_sections[i].new_data = NULL;
+      debug_sections[i].new_size = 0;
+      debug_sections[i].sec = 0;
+    }
+
+  return fd;
+}
+
+/* Parse the .debug_* sections from shared ET_REL file written
+   by optimize_multifile into data structures for fi_multifile
+   phase.  */
+static DSO *
+read_multifile (int fd, unsigned int die_count)
+{
+  DSO *dso, *volatile ret;
+  unsigned int i;
+
+  if (unlikely (progress_p))
+    {
+      report_progress ();
+      fprintf (stderr, "read_multifile\n");
+    }
+
+  if (tracing)
+    fprintf (stderr, "Read-multifile\n");
+
+  multifile_mode = MULTIFILE_MODE_RD;
+  dso = fdopen_dso (fd, multifile);
+  if (dso == NULL)
+    {
+      multifile_mode = 0;
+      return NULL;
+    }
+
+  ret = dso;
+  obstack_alloc_failed_handler = dwz_oom;
+  if (setjmp (oom_buf))
+    {
+      error (0, ENOMEM, "%s: Could not allocate memory", dso->filename);
+
+    fail:
+      elf_end (dso->elf);
+      close (fd);
+      free (dso);
+      ret = NULL;
+      alt_off_htab = NULL;
+    }
+  else
+    {
+      obstack_init (&ob);
+      obstack_init (&ob2);
+
+      if (read_dwarf (dso, false, &die_count))
+	goto fail;
+
+      if (debug_sections[DEBUG_STR].size)
+	{
+	  unsigned char *p, *q;
+	  unsigned int strp_count = debug_sections[DEBUG_STR].size / 64;
+	  void **slot;
+	  unsigned int *pi;
+
+	  if (strp_count < 100)
+	    strp_count = 100;
+	  strp_htab = htab_try_create (strp_count, strp_hash3, strp_eq3, NULL);
+	  if (strp_htab == NULL)
+	    dwz_oom ();
+	  for (p = debug_sections[DEBUG_STR].data;
+	       p < debug_sections[DEBUG_STR].data
+		   + debug_sections[DEBUG_STR].size; p = q)
+	    {
+	      q = (unsigned char *) strchr ((char *) p, '\0') + 1;
+	      slot = htab_find_slot_with_hash (strp_htab, p,
+					       hash (p, q - p - 1), INSERT);
+	      if (slot == NULL)
+		dwz_oom ();
+	      assert (*slot == NULL);
+	      *slot = (void *) p;
+	    }
+	  if (strp_tail_off_list)
+	    {
+	      for (pi = strp_tail_off_list; *pi; pi++)
+		{
+		  p = debug_sections[DEBUG_STR].data + *pi;
+		  q = (unsigned char *) strchr ((char *) p, '\0');
+		  slot = htab_find_slot_with_hash (strp_htab, p,
+						   hash (p, q - p), INSERT);
+		  if (slot == NULL)
+		    dwz_oom ();
+		  assert (*slot == NULL);
+		  *slot = (void *) p;
+		}
+	      pi++;
+	      munmap (strp_tail_off_list,
+		      (char *) pi - (char *) strp_tail_off_list);
+	    }
+	}
+
+      if (debug_sections[DEBUG_MACRO].data)
+	handle_macro ();
+
+      alt_strp_htab = strp_htab;
+      strp_htab = NULL;
+      alt_off_htab = off_htab;
+      off_htab = NULL;
+      alt_dup_htab = dup_htab;
+      dup_htab = NULL;
+      alt_macro_htab = macro_htab;
+      macro_htab = NULL;
+      alt_first_cu = first_cu;
+      alt_pool = finalize_pool ();
+      alt_ob = ob;
+      alt_ob2 = ob2;
+      memset (&ob, '\0', sizeof (ob));
+      memset (&ob2, '\0', sizeof (ob2));
+      for (i = 0; i < SAVED_SECTIONS; i++)
+	{
+	  alt_data[i] = debug_sections[i].data;
+	  alt_size[i] = debug_sections[i].size;
+	}
+    }
+
+  cleanup ();
+
+  for (i = 0; debug_sections[i].name; ++i)
+    {
+      debug_sections[i].data = NULL;
+      debug_sections[i].size = 0;
+      debug_sections[i].new_data = NULL;
+      debug_sections[i].new_size = 0;
+      debug_sections[i].sec = 0;
+    }
+
+  return ret;
+}
+
+/* Clear all die_nextdup fields among toplevel children
+   of DIE.  */
+static void
+alt_clear_dups (dw_die_ref die)
+{
+  dw_die_ref child;
+  assert (die->die_dup == NULL);
+  die->die_nextdup = NULL;
+  for (child = die->die_child; child; child = child->die_sib)
+    {
+      assert (child->die_dup == NULL);
+      child->die_nextdup = NULL;
+      if (child->die_named_namespace)
+	alt_clear_dups (child);
+    }
+}
+
+/* Create a temporary file using NAME.  Return the corresponding file
+   descriptor if successful, otherwise return -1.  */
+static int
+make_temp_file (const char *name)
+{
+  const char *tmpdir = "/tmp/";
+  const char *template_suffix = ".XXXXXX";
+  int fd;
+  size_t buf_len, offset, name_len;
+  char *buf;
+
+  if (save_temps)
+    {
+      FILE *f = fopen (name, "w+");
+      if (f == NULL)
+	fd = -1;
+      else
+	fd = fileno (f);
+      return fd;
+    }
+
+  name_len = strlen (name);
+  buf_len = (strlen (tmpdir)
+	     + name_len
+	     + strlen (template_suffix)
+	     + 1);
+  if (buf_len < name_len)
+    return -1;
+  buf = (char *)malloc (buf_len);
+  if (buf == NULL)
+    return -1;
+  offset = 0;
+
+  strcpy (&buf[offset], tmpdir);
+  offset += strlen (tmpdir);
+
+  strcpy (&buf[offset], name);
+  offset += name_len;
+
+  strcpy (&buf[offset], template_suffix);
+  offset += strlen (template_suffix);
+
+  assert (offset == buf_len - 1);
+  assert (buf[offset] == '\0');
+
+  fd = mkstemp (buf);
+  if (fd == -1)
+    goto done;
+
+  /* Unlink the filename, such that the file is disposed of once the file
+     descriptor is closed.  */
+  unlink (buf);
+
+ done:
+  free (buf);
+  return fd;
+}
+
+/* As dwz, but retry with MULTIFILE_MODE_LOW_MEM if the low_mem_die_limit
+   is hit.  */
+static int
+dwz_with_low_mem (const char *file, const char *outfile,
+		  struct file_result *res)
+{
+  int ret;
+
+  res->low_mem_p = false;
+
+  ret = (low_mem_die_limit == 0
+	 ? 2
+	 : dwz (file, outfile, res));
+
+  if (ret == 2)
+    {
+      multifile_mode = MULTIFILE_MODE_LOW_MEM;
+      res->low_mem_p = true;
+
+      ret = dwz (file, outfile, res);
+    }
+
+  return ret;
+}
+
+/* Initialize struct file_result RES.  */
+static void
+init_file_result (struct file_result *res)
+{
+  res->die_count = 0;
+  res->res = -3;
+  res->skip_multifile = false;
+  res->low_mem_p = false;
+}
+
+/* Dwarf-compress FILE.  If OUTFILE, write to result to OUTFILE, otherwise
+   modify FILE.  */
+static int
+dwz_one_file (const char *file, const char *outfile)
+{
+  struct file_result res;
+
+  if (stats_p)
+    init_stats (file);
+
+  init_file_result (&res);
+
+  return dwz_with_low_mem (file, outfile, &res);
+}
+
+/* Helper structure for hardlink discovery.  */
+struct hl_stat
+{
+  dev_t dev;
+  ino_t ino;
+  nlink_t nlink;
+};
+
+/* Detect which FILES are hardlinks, and mark those in RESA.  */
+static bool
+detect_hardlinks (int nr_files, char *files[], struct file_result *resa)
+{
+  bool found = false;
+  struct hl_stat hl_stat[nr_files];
+  int i;
+
+  /* Try to open all files.  */
+  for (i = 0; i < nr_files; i++)
+    {
+      struct file_result *res = &resa[i];
+      int fd;
+      struct stat st;
+
+      const char *file = files[i];
+      res->res = -1;
+
+      fd = open (file, O_RDONLY);
+      if (fd < 0)
+	error (0, errno, "Failed to open input file %s", file);
+      else if (fstat (fd, &st) < 0)
+	error (0, errno, "Failed to stat input file %s", file);
+      else
+	{
+	  res->res = 1;
+	  hl_stat[i].dev = st.st_dev;
+	  hl_stat[i].ino = st.st_ino;
+	  hl_stat[i].nlink = st.st_nlink;
+	}
+
+      close (fd);
+    }
+
+  /* Detect hard links.  */
+  for (i = 0; i < nr_files; i++)
+    {
+      struct file_result *res = &resa[i];
+      int n;
+      for (n = 0; n != i; n++)
+	if (resa[n].res >= 0
+	    && hl_stat[n].nlink > 1
+	    && hl_stat[n].dev == hl_stat[i].dev
+	    && hl_stat[n].ino == hl_stat[i].ino)
+	  break;
+      if (n == i)
+	continue;
+      res->res = -2;
+      res->hardlink_to = n;
+      found = true;
+    }
+
+  return found;
+}
+
+/* Update the FILES marked as hardlink in RESA.  */
+static void
+update_hardlinks (int nr_files, char *files[], struct file_result *resa)
+{
+  int i;
+
+  /* Update hardlinks.  */
+  for (i = 0; i < nr_files; i++)
+    {
+      struct file_result *res = &resa[i];
+      const char *file = files[i];
+      size_t n;
+      if (res->res != -2)
+	continue;
+      n = res->hardlink_to;
+
+      /* If a hardlink to this has been processed before
+	 and we didn't change it, just assume the same
+	 state.  */
+      if (resa[n].res == 1)
+	{
+	  if (tracing)
+	    fprintf (stderr, "Skipping hardlink %s to unchanged file\n",
+		     file);
+	  continue;
+	}
+
+      /* If it changed, try to hardlink it again.  */
+      if (resa[n].res == 0)
+	{
+	  size_t len = strlen (file);
+	  char *filename = alloca (len + sizeof (".#dwz#.XXXXXX"));
+	  int fd2;
+	  if (tracing)
+	    fprintf (stderr, "Updating hardlink %s to changed file\n",
+		     file);
+	  memcpy (filename, file, len);
+	  memcpy (filename + len, ".#dwz#.XXXXXX",
+		  sizeof (".#dwz#.XXXXXX"));
+	  fd2 = mkstemp (filename);
+	  if (fd2 >= 0)
+	    {
+	      close (fd2);
+	      unlink (filename);
+	      if (link (files[n], filename) == 0)
+		{
+		  if (rename (filename, file) == 0)
+		    ;
+		  else
+		    unlink (filename);
+		}
+	    }
+	}
+    }
+}
+
+/* Encode child process exit status.  */
+static int
+encode_child_exit_status (int thisret, struct file_result *res)
+{
+  assert (thisret == 0 ||  thisret == 1);
+  if (thisret == 0 && res->low_mem_p)
+    thisret = 2;
+  assert (res->res >= -3 && res->res <= 1);
+  return (thisret
+	  + ((res->res + 3) << 2)
+	  + ((res->skip_multifile ? 1 : 0) << 5));
+}
+
+/* Decode child process exit status.  */
+static int
+decode_child_exit_status (int state, struct file_result *res)
+{
+  int ret;
+  if (!WIFEXITED (state))
+    error (1, 0, "Child dwz process got killed");
+  int status = WEXITSTATUS (state);
+  ret = status & 0x3;
+  status >>= 2;
+
+  res->low_mem_p = false;
+  if (ret == 2)
+    {
+      ret = 0;
+      res->low_mem_p = true;
+    }
+
+  res->res = (int)(status & 0x7) - 3;
+  status >>= 3;
+
+  res->skip_multifile = (status & 0x1) ? true : false;
+
+  return ret;
+}
+
+/* Wait on child exit with PID, update PIDS and RES.  */
+static void
+wait_child_exit (pid_t pid, pid_t *pids, int nr_pids,
+		 struct file_result *resa)
+{
+  int state;
+  pid_t got_pid = waitpid (pid, &state, 0);
+
+  int i;
+  for (i = 0; i < nr_pids; ++i)
+    if (pids[i] == got_pid)
+      {
+	pids[i] = 0;
+	break;
+      }
+  assert (i < nr_pids);
+
+  resa[i].ret = decode_child_exit_status (state, &resa[i]);
+}
+
+static int *workset;
+static int workset_size = 0;
+int current_multifile_owner = -1;
+int current_multifile_owner_file_idx = -1;
+
+/* Wait on exit of chilren in PIDS, update RESA.  */
+static void
+wait_children_exit (pid_t *pids, int nr_files, struct file_result *resa)
+{
+  int i;
+  for (i = 0; i < nr_files; i++)
+    {
+      struct file_result *res = &resa[i];
+      if (pids[i] == 0)
+	continue;
+      wait_child_exit (pids[i], &pids[i], 1, res);
+      if (current_multifile_owner_file_idx == -1
+	  || i < current_multifile_owner_file_idx)
+	continue;
+      assert (i == current_multifile_owner_file_idx);
+      current_multifile_owner++;
+      if (current_multifile_owner == workset_size)
+	continue;
+      current_multifile_owner_file_idx
+	= workset[current_multifile_owner];
+      pass_token (current_multifile_owner);
+    }
+}
+
+/* Dwarf-compress FILES.  If HARDLINK, detect if some files are hardlinks and
+   if so, dwarf-compress just one, and relink the others.  */
+static int
+dwz_files_1 (int nr_files, char *files[], bool hardlink,
+	     struct file_result *resa)
+{
+  int ret = 0;
+  int i, j;
+  const char *file;
+  int successcount = 0;
+
+  for (i = 0; i < nr_files; ++i)
+    init_file_result (&resa[i]);
+
+  if (multifile)
+    {
+      if (multifile_force_ptr_size)
+	multi_ptr_size = multifile_force_ptr_size;
+      if (multifile_force_endian)
+	multi_endian = multifile_force_endian;
+
+      multi_info_fd = make_temp_file ("dwz.debug_info");
+      multi_abbrev_fd = make_temp_file ("dwz.debug_abbrev");
+      multi_line_fd = make_temp_file ("dwz.debug_line");
+      multi_str_fd = make_temp_file ("dwz.debug_str");
+      multi_macro_fd = make_temp_file ("dwz.debug_macro");
+      if (multi_info_fd == -1
+	  || multi_abbrev_fd == -1
+	  || multi_line_fd == -1
+	  || multi_str_fd == -1
+	  || multi_macro_fd == -1)
+	{
+	  error (0, 0, "Could not create multifile temporary files");
+	  multifile = NULL;
+	}
+    }
+
+  if (hardlink)
+    hardlink = detect_hardlinks (nr_files, files, resa);
+
+  workset = malloc (nr_files * sizeof (int));
+  if (workset == NULL)
+    error (1, ENOMEM, "failed to allocate workset array");
+  for (i = 0; i < nr_files; i++)
+    {
+      struct file_result *res = &resa[i];
+      if (res->res == -2)
+	/* Skip hard links.  */
+	continue;
+      workset[workset_size] = i;
+      workset_size++;
+    }
+
+  bool initial_parallel_p = max_forks > 1;
+  if (initial_parallel_p && multifile)
+    {
+     if (multifile_force_ptr_size != 0 && multifile_force_endian != 0)
+       {
+	 write_multifile_parallel_p = true;
+	 pipes = malloc (workset_size * 2 * sizeof (int));
+	 if (pipes == NULL)
+	   error (1, ENOMEM, "failed to allocate pipes array");
+	 for (i = 0; i < workset_size; i++)
+	   {
+	     int fds[2];
+	     if (pipe (fds) != 0)
+	       error (1, ENOMEM, "failed to initialize pipe");
+	     pipes[i].readfd = fds[0];
+	     pipes[i].writefd = fds[1];
+	   }
+       }
+     else
+       initial_parallel_p = false;
+    }
+  if (initial_parallel_p)
+    {
+      pid_t pids[nr_files];
+      int nr_forks = 0;
+      for (i = 0; i < nr_files; i++)
+	pids[i] = 0;
+      for (j = 0; j < workset_size; j++)
+	{
+	  int i = workset[j];
+
+	  if (nr_forks == max_forks)
+	    {
+	      if (multifile == NULL)
+		wait_child_exit (-1, pids, i, resa);
+	      else
+		{
+		  int k = current_multifile_owner_file_idx;
+		  wait_child_exit (pids[k], &pids[k], 1, &resa[k]);
+		  current_multifile_owner++;
+		  current_multifile_owner_file_idx
+		    = workset[current_multifile_owner];
+		  pass_token (current_multifile_owner);
+		}
+	      nr_forks--;
+	    }
+
+	  pid_t fork_res = fork ();
+	  assert (fork_res != -1);
+	  if (fork_res == 0)
+	    {
+	      child_id = j;
+	      file = files[i];
+	      struct file_result *res = &resa[i];
+	      int thisret = dwz_with_low_mem (file, NULL, res);
+	      return encode_child_exit_status (thisret, res);
+	    }
+	  else
+	    {
+	      if (multifile && j == 0)
+		{
+		  current_multifile_owner = j;
+		  current_multifile_owner_file_idx
+		    = workset[current_multifile_owner];
+		  pass_token (current_multifile_owner);
+		}
+	      pids[i] = fork_res;
+	      nr_forks++;
+	    }
+	}
+      if (nr_forks > 0)
+	wait_children_exit (pids, nr_files, resa);
+    }
+  else
+    {
+      for (j = 0; j < workset_size; j++)
+	{
+	  int i = workset[j];
+	  file = files[i];
+	  struct file_result *res = &resa[i];
+	  if (stats_p)
+	    init_stats (file);
+	  res->ret = dwz_with_low_mem (file, NULL, res);
+	}
+    }
+
+  for (j = 0; j < workset_size; j++)
+    {
+      int i = workset[j];
+      struct file_result *res = &resa[i];
+      int thisret = res->ret;
+      if (thisret == 1)
+	ret = 1;
+      else if (!res->low_mem_p && !res->skip_multifile && res->res >= 0)
+	successcount++;
+    }
+
+  if (hardlink)
+    update_hardlinks (nr_files, files, resa);
+
+  if (multifile == NULL)
+    return ret;
+
+  if (successcount < 2)
+    {
+      error (0, 0, "Too few files for multifile optimization");
+      return ret;
+    }
+
+  if (write_multifile_parallel_p)
+    {
+      multi_info_off = lseek (multi_info_fd, 0L, SEEK_END);
+      multi_abbrev_off = lseek (multi_abbrev_fd, 0L, SEEK_END);
+      multi_line_off = lseek (multi_line_fd, 0L, SEEK_END);
+      multi_str_off = lseek (multi_str_fd, 0L, SEEK_END);
+      multi_macro_off = lseek (multi_macro_fd, 0L, SEEK_END);
+    }
+  if (multi_info_off == 0 && multi_str_off == 0 && multi_macro_off == 0)
+    {
+      if (!quiet)
+	error (0, 0, "No suitable DWARF found for multifile optimization");
+      return ret;
+    }
+
+  if (write_multifile_parallel_p)
+    {
+      /* We reproduce here what happens when we run sequentially.  This is a
+	 kludge that probably needs to be replaced by IPC.  */
+      for (i = 0; i < nr_files; i++)
+	{
+	  struct file_result *res = &resa[i];
+	  if (!res->low_mem_p && !res->skip_multifile && res->res >= 0)
+	    {
+	      int fd = open (files[i], O_RDONLY);
+	      if (fd < 0)
+		return ret;
+	      DSO *dso = fdopen_dso (fd, files[i]);
+	      if (dso == NULL)
+		{
+		  close (fd);
+		  return ret;
+		}
+	      assert (multi_ehdr.e_ident[0] == '\0');
+	      multi_ehdr = dso->ehdr;
+	      break;
+	    }
+	}
+    }
+
+  unsigned int multifile_die_count = 0;
+  int multi_fd = optimize_multifile (&multifile_die_count);
+  DSO *dso;
+  if (multi_fd == -1)
+    return 1;
+
+  dso = read_multifile (multi_fd, multifile_die_count);
+  if (dso == NULL)
+    {
+      ret = 1;
+      goto cleanup;
+    }
+
+  workset_size = 0;
+  for (i = 0; i < nr_files; i++)
+    {
+      struct file_result *res = &resa[i];
+      /* Don't process again files that couldn't
+	 be processed successfully.  Also skip hard links.  */
+      if (res->res == -1 || res->res == -2
+	  || res->skip_multifile)
+	continue;
+      workset[workset_size] = i;
+      workset_size++;
+    }
+
+  bool finalize_multifile_parallel_p = max_forks > 1;
+  if (finalize_multifile_parallel_p)
+    {
+      pid_t pids[nr_files];
+      int nr_forks = 0;
+      for (i = 0; i < nr_files; i++)
+	pids[i] = 0;
+      for (j = 0; j < workset_size; j++)
+	{
+	  int i = workset[j];
+
+	  if (nr_forks == max_forks)
+	    {
+	      wait_child_exit (-1, pids, i, resa);
+	      nr_forks--;
+	    }
+
+	  pid_t fork_res = fork ();
+	  assert (fork_res != -1);
+	  if (fork_res == 0)
+	    {
+	      file = files[i];
+	      struct file_result *res = &resa[i];
+	      multifile_mode = MULTIFILE_MODE_FI;
+	      int thisret = dwz (file, NULL, res);
+	      return encode_child_exit_status (thisret, res);
+	    }
+	  else
+	    {
+	      pids[i] = fork_res;
+	      nr_forks++;
+	    }
+	}
+      if (nr_forks > 0)
+	wait_children_exit (pids, nr_files, resa);
+    }
+  else
+    {
+      for (j = 0; j < workset_size; j++)
+	{
+	  int i = workset[j];
+	  struct file_result *res = &resa[i];
+	  dw_cu_ref cu;
+	  file = files[i];
+	  if (stats_p)
+	    init_stats (file);
+	  multifile_mode = MULTIFILE_MODE_FI;
+	  for (cu = alt_first_cu; cu; cu = cu->cu_next)
+	    alt_clear_dups (cu->cu_die);
+	  res->ret = dwz (file, NULL, res);
+	}
+    }
+
+  for (j = 0; j < workset_size; j++)
+    {
+      int i = workset[j];
+      struct file_result *res = &resa[i];
+      int thisret = res->ret;
+      ret |= thisret;
+    }
+
+  if (hardlink)
+    update_hardlinks (nr_files, files, resa);
+
+  elf_end (dso->elf);
+  close (multi_fd);
+  free (dso);
+
+ cleanup:
+  cleanup ();
+
+  strp_htab = alt_strp_htab;
+  off_htab = alt_off_htab;
+  dup_htab = alt_dup_htab;
+  macro_htab = alt_macro_htab;
+  ob = alt_ob;
+  ob2 = alt_ob2;
+  cleanup ();
+  pool_destroy (alt_pool);
+
+  return ret;
+}
+
+/* Wrapper around dwz_files_1 that takes care of malloc and free of resa.  */
+static int
+dwz_files (int nr_files, char *files[], bool hardlink)
+{
+  int ret;
+  struct file_result *resa
+    = (struct file_result *) malloc ((nr_files) * sizeof (*resa));
+  if (resa == NULL)
+    error (1, ENOMEM, "failed to allocate result array");
+
+  ret = dwz_files_1 (nr_files, files, hardlink, resa);
+
+  free (resa);
+  return ret;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+  const char *outfile;
+  bool hardlink;
+  int nr_files;
+  char **files;
+
+  state = XXH64_createState ();
+
+  if (elf_version (EV_CURRENT) == EV_NONE)
+    error (1, 0, "library out of date");
+
+  outfile = NULL;
+  hardlink = false;
+  parse_args (argc, argv, &hardlink, &outfile);
+  nr_files = argc - optind;
+  files = &argv[optind];
+
+  if (nr_files <= 1)
+    {
+      const char *file = nr_files == 0 ? "a.out" : files[0];
+
+      if (multifile != NULL)
+	{
+	  error (0, 0, "Too few files for multifile optimization");
+	  multifile = NULL;
+	}
+
+      ret = dwz_one_file (file, outfile);
+    }
+  else
+    {
+      if (outfile != NULL)
+	error (1, 0, "-o option not allowed for multiple files");
+
+      ret = dwz_files (nr_files, files, hardlink);
+    }
+
+  if (stats_p)
+    free (stats);
+
+  return ret;
+}