/* Copyright (C) 2001-2003, 2005, 2007, 2009-2011, 2016, 2017 Red Hat, Inc.
   Written by Alexander Larsson <alexl@redhat.com>, 2002
   Based on code by Jakub Jelinek <jakub@redhat.com>, 2001.
   String/Line table rewriting by Mark Wielaard <mjw@redhat.com>, 2017.

   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; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <assert.h>
#include <byteswap.h>
#include <endian.h>
#include <errno.h>
#include <error.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <getopt.h>

#include <gelf.h>
#include <dwarf.h>

#ifndef MAX
#define MAX(m, n) ((m) < (n) ? (n) : (m))
#endif


/* Unfortunately strtab manipulation functions were only officially added
   to elfutils libdw in 0.167.  Before that there were internal unsupported
   ebl variants.  While libebl.h isn't supported we'll try to use it anyway
   if the elfutils we build against is too old.  */
#include <elfutils/version.h>
#if _ELFUTILS_PREREQ (0, 167)
#include <elfutils/libdwelf.h>
typedef Dwelf_Strent		Strent;
typedef Dwelf_Strtab		Strtab;
#define strtab_init		dwelf_strtab_init
#define strtab_add(X,Y)		dwelf_strtab_add(X,Y)
#define strtab_add_len(X,Y,Z)	dwelf_strtab_add_len(X,Y,Z)
#define strtab_free		dwelf_strtab_free
#define strtab_finalize		dwelf_strtab_finalize
#define strent_offset		dwelf_strent_off
#else
#include <elfutils/libebl.h>
typedef struct Ebl_Strent	Strent;
typedef struct Ebl_Strtab	Strtab;
#define strtab_init		ebl_strtabinit
#define strtab_add(X,Y)		ebl_strtabadd(X,Y,0)
#define strtab_add_len(X,Y,Z)	ebl_strtabadd(X,Y,Z)
#define strtab_free		ebl_strtabfree
#define strtab_finalize		ebl_strtabfinalize
#define strent_offset		ebl_strtaboffset
#endif

#include <search.h>

#include "tools/hashtab.h"

#include "tools/md5.h"
#include "tools/sha1.h"

#define DW_TAG_partial_unit 0x3c
#define DW_FORM_sec_offset 0x17
#define DW_FORM_exprloc 0x18
#define DW_FORM_flag_present 0x19
#define DW_FORM_ref_sig8 0x20

char *base_dir = NULL;
char *dest_dir = NULL;
char *list_file = NULL;
int list_file_fd = -1;
int do_build_id = 0;
int no_recompute_build_id = 0;
char *build_id_seed = NULL;

int show_version = 0;

/* We go over the debug sections in two phases. In phase zero we keep
   track of any needed changes and collect strings, indexes and
   sizes. In phase one we do the actual replacements updating the
   strings, indexes and writing out new debug sections. The following
   keep track of various changes that might be needed. */

/* Whether we need to do any literal string (DW_FORM_string) replacements
   in debug_info. */
static bool need_string_replacement = false;
/* Whether we need to do any updates of the string indexes (DW_FORM_strp)
   in debug_info for string indexes. */
static bool need_strp_update = false;
/* Likewise for DW_FORM_line_strp. */
static bool need_line_strp_update = false;
/* If the debug_line changes size we will need to update the
   DW_AT_stmt_list attributes indexes in the debug_info. */
static bool need_stmt_update = false;

/* Storage for dynamically allocated strings to put into string
   table. Keep together in memory blocks of 16K. */
#define STRMEMSIZE (16 * 1024)
struct strmemblock
{
  struct strmemblock *next;
  char memory[0];
};

/* We keep track of each index in the original string table and the
   associated entry in the new table so we don't insert identical
   strings into the new string table. If constructed correctly the
   original strtab shouldn't contain duplicate strings anyway. Any
   actual identical strings could be deduplicated, but searching for
   and comparing the indexes is much faster than comparing strings
   (and we don't have to construct replacement strings). */
struct stridxentry
{
  uint32_t idx; /* Original index in the string table. */
  Strent *entry; /* Entry in the new table. */
};

/* Storage for new string table entries. Keep together in memory to
   quickly search through them with tsearch. */
#define STRIDXENTRIES ((16 * 1024) / sizeof (struct stridxentry))
struct strentblock
{
  struct strentblock *next;
  struct stridxentry entry[0];
};

/* All data to keep track of the existing and new string table. */
struct strings
{
  Strtab *str_tab;			/* The new string table. */
  char *str_buf;			/* New Elf_Data d_buf. */
  struct strmemblock *blocks;		/* The first strmemblock. */
  struct strmemblock *last_block;	/* The currently used strmemblock. */
  size_t stridx;			/* Next free byte in last block. */
  struct strentblock *entries;		/* The first string index block. */
  struct strentblock *last_entries;	/* The currently used strentblock. */
  size_t entryidx;			/* Next free entry in the last block. */
  void *strent_root;			/* strent binary search tree root. */
};

struct line_table
{
  size_t old_idx;     /* Original offset. */
  size_t new_idx;     /* Offset in new debug_line section. */
  ssize_t size_diff;  /* Difference in (header) size. */
  bool replace_dirs;  /* Whether to replace any dir paths.  */
  bool replace_files; /* Whether to replace any file paths. */

  /* Header fields. */
  uint32_t unit_length;
  uint16_t version;
  uint32_t header_length;
  uint8_t min_instr_len;
  uint8_t max_op_per_instr; /* Only if version >= 4 */
  uint8_t default_is_stmt;
  int8_t line_base;
  uint8_t line_range;
  uint8_t opcode_base;
};

struct debug_lines
{
  struct line_table *table; /* Malloc/Realloced. */
  size_t size;              /* Total number of line_tables.
			       Updated by get_line_table. */
  size_t used;              /* Used number of line_tables.
			       Updated by get_line_table. */
  size_t debug_lines_len;   /* Total size of new debug_line section.
			       updated by edit_dwarf2_line. */
  char *line_buf;           /* New Elf_Data d_buf. */
};

typedef struct
{
  Elf *elf;
  GElf_Ehdr ehdr;
  Elf_Scn **scn;
  const char *filename;
  int lastscn;
  size_t phnum;
  struct strings debug_str, debug_line_str;
  struct debug_lines lines;
  GElf_Shdr shdr[0];
} DSO;

static void
setup_lines (struct debug_lines *lines)
{
  lines->table = NULL;
  lines->size = 0;
  lines->used = 0;
  lines->debug_lines_len = 0;
  lines->line_buf = NULL;
}

static void
destroy_lines (struct debug_lines *lines)
{
  free (lines->table);
  free (lines->line_buf);
}

typedef struct
{
  unsigned char *ptr;
  uint32_t addend;
  int ndx;
} REL;

typedef struct
{
  Elf64_Addr r_offset;
  int ndx;
} LINE_REL;

#define read_uleb128(ptr) ({		\
  unsigned int ret = 0;			\
  unsigned int c;			\
  int shift = 0;			\
  do					\
    {					\
      c = *(ptr)++;			\
      ret |= (c & 0x7f) << shift;	\
      shift += 7;			\
    } while (c & 0x80);			\
					\
  if (shift >= 35)			\
    ret = UINT_MAX;			\
  ret;					\
})

#define write_uleb128(ptr,val) ({	\
  uint32_t valv = (val);		\
  do					\
    {					\
      unsigned char c = valv & 0x7f;	\
      valv >>= 7;			\
      if (valv)				\
	c |= 0x80;			\
      *(ptr)++ = c;			\
    }					\
  while (valv);				\
})

static uint16_t (*do_read_16) (unsigned char *ptr);
static uint32_t (*do_read_32) (unsigned char *ptr);
static void (*do_write_16) (unsigned char *ptr, uint16_t val);
static void (*do_write_32) (unsigned char *ptr, uint32_t val);

static int ptr_size;
static int cu_version;

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) | (data[3] << 24);
}

static inline uint32_t
buf_read_ube32 (unsigned char *data)
{
  return data[3] | (data[2] << 8) | (data[1] << 16) | (data[0] << 24);
}

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_getdata (scn, data)) != NULL)
	{
	  if (data->d_buf
	      && offset >= data->d_off
	      && offset < data->d_off + data->d_size)
	    return (const char *) data->d_buf + (offset - data->d_off);
	}
    }

  return NULL;
}


#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;							\
})

REL *relptr, *relend;
int reltype;

#define do_read_32_relocated(xptr) ({			\
  uint32_t dret = do_read_32 (xptr);			\
  if (relptr)						\
    {							\
      while (relptr < relend && relptr->ptr < (xptr))	\
	++relptr;					\
      if (relptr < relend && relptr->ptr == (xptr))	\
	{						\
	  if (reltype == SHT_REL)			\
	    dret += relptr->addend;			\
	  else						\
	    dret = relptr->addend;			\
	}						\
    }							\
  dret;							\
})

#define read_32_relocated(ptr) ({			\
  uint32_t ret = do_read_32_relocated (ptr);		\
  ptr += 4;						\
  ret;							\
})

static void
dwarf2_write_le16 (unsigned char *p, uint16_t v)
{
  p[0] = v;
  p[1] = v >> 8;
}

static void
dwarf2_write_le32 (unsigned char *p, uint32_t v)
{
  p[0] = v;
  p[1] = v >> 8;
  p[2] = v >> 16;
  p[3] = v >> 24;
}

static void
dwarf2_write_be16 (unsigned char *p, uint16_t v)
{
  p[1] = v;
  p[0] = v >> 8;
}

static void
dwarf2_write_be32 (unsigned char *p, uint32_t v)
{
  p[3] = v;
  p[2] = v >> 8;
  p[1] = v >> 16;
  p[0] = v >> 24;
}

#define write_8(ptr,val) ({	\
  *ptr++ = (val);		\
})

#define write_16(ptr,val) ({	\
  do_write_16 (ptr,val);	\
  ptr += 2;			\
})

#define write_32(ptr,val) ({	\
  do_write_32 (ptr,val);	\
  ptr += 4;			\
})

/* relocated writes can only be called immediately after
   do_read_32_relocated.  ptr must be equal to relptr->ptr (or
   relend). Might just update the addend. So relocations need to be
   updated at the end.  */

static bool rel_updated;

#define do_write_32_relocated(ptr,val) ({ \
  if (relptr && relptr < relend && relptr->ptr == ptr)	\
    {							\
      if (reltype == SHT_REL)				\
	do_write_32 (ptr, val - relptr->addend);	\
      else						\
	{						\
	  relptr->addend = val;				\
	  rel_updated = true;				\
	}						\
    }							\
  else							\
    do_write_32 (ptr,val);				\
})

#define write_32_relocated(ptr,val) ({ \
  do_write_32_relocated (ptr,val);     \
  ptr += 4;			       \
})

typedef struct debug_section
  {
    const char *name;
    unsigned char *data;
    Elf_Data *elf_data;
    size_t size;
    int sec, relsec;
    REL *relbuf;
    REL *relend;
    /* Only happens for COMDAT .debug_macro and .debug_types.  */
    struct debug_section *next;
  } debug_section;

static debug_section debug_sections[] =
  {
#define DEBUG_INFO	0
#define DEBUG_ABBREV	1
#define DEBUG_LINE	2
#define DEBUG_ARANGES	3
#define DEBUG_PUBNAMES	4
#define DEBUG_PUBTYPES	5
#define DEBUG_MACINFO	6
#define DEBUG_LOC	7
#define DEBUG_STR	8
#define DEBUG_FRAME	9
#define DEBUG_RANGES	10
#define DEBUG_TYPES	11
#define DEBUG_MACRO	12
#define DEBUG_GDB_SCRIPT	13
#define DEBUG_RNGLISTS	14
#define DEBUG_LINE_STR	15
#define DEBUG_ADDR	16
#define DEBUG_STR_OFFSETS	17
#define DEBUG_LOCLISTS	18
    { ".debug_info", NULL, NULL, 0, 0, 0 },
    { ".debug_abbrev", NULL, NULL, 0, 0, 0 },
    { ".debug_line", 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_macinfo", NULL, NULL, 0, 0, 0 },
    { ".debug_loc", NULL, NULL, 0, 0, 0 },
    { ".debug_str", NULL, NULL, 0, 0, 0 },
    { ".debug_frame", NULL, NULL, 0, 0, 0 },
    { ".debug_ranges", NULL, NULL, 0, 0, 0 },
    { ".debug_types", NULL, NULL, 0, 0, 0 },
    { ".debug_macro", NULL, NULL, 0, 0, 0 },
    { ".debug_gdb_scripts", NULL, NULL, 0, 0, 0 },
    { ".debug_rnglists", NULL, NULL, 0, 0, 0 },
    { ".debug_line_str", NULL, NULL, 0, 0, 0 },
    { ".debug_addr", NULL, NULL, 0, 0, 0 },
    { ".debug_str_offsets", NULL, NULL, 0, 0, 0 },
    { ".debug_loclists", NULL, NULL, 0, 0, 0 },
    { NULL, NULL, NULL, 0, 0, 0 }
  };

static int
rel_cmp (const void *a, const void *b)
{
  REL *rela = (REL *) a, *relb = (REL *) b;

  if (rela->ptr < relb->ptr)
    return -1;

  if (rela->ptr > relb->ptr)
    return 1;

  return 0;
}

/* Returns a malloced REL array, or NULL when there are no relocations
   for this section.  When there are relocations, will setup relend,
   as the last REL, and reltype, as SHT_REL or SHT_RELA.  */
static void
setup_relbuf (DSO *dso, debug_section *sec, int *reltype)
{
  int ndx, maxndx;
  GElf_Rel rel;
  GElf_Rela rela;
  GElf_Sym sym;
  GElf_Addr base = dso->shdr[sec->sec].sh_addr;
  Elf_Data *symdata = NULL;
  int rtype;
  REL *relbuf;
  Elf_Scn *scn;
  Elf_Data *data;
  int i = sec->relsec;

  /* No relocations, or did we do this already? */
  if (i == 0 || sec->relbuf != NULL)
    {
      relptr = sec->relbuf;
      relend = sec->relend;
      return;
    }

  scn = dso->scn[i];
  data = elf_getdata (scn, NULL);
  assert (data != NULL && data->d_buf != NULL);
  assert (elf_getdata (scn, data) == NULL);
  assert (data->d_off == 0);
  assert (data->d_size == dso->shdr[i].sh_size);
  maxndx = dso->shdr[i].sh_size / dso->shdr[i].sh_entsize;
  relbuf = malloc (maxndx * sizeof (REL));
  *reltype = dso->shdr[i].sh_type;
  if (relbuf == NULL)
    error (1, errno, "%s: Could not allocate memory", dso->filename);

  symdata = elf_getdata (dso->scn[dso->shdr[i].sh_link], NULL);
  assert (symdata != NULL && symdata->d_buf != NULL);
  assert (elf_getdata (dso->scn[dso->shdr[i].sh_link], symdata) == NULL);
  assert (symdata->d_off == 0);
  assert (symdata->d_size == dso->shdr[dso->shdr[i].sh_link].sh_size);

  for (ndx = 0, relend = relbuf; ndx < maxndx; ++ndx)
    {
      if (dso->shdr[i].sh_type == SHT_REL)
	{
	  gelf_getrel (data, ndx, &rel);
	  rela.r_offset = rel.r_offset;
	  rela.r_info = rel.r_info;
	  rela.r_addend = 0;
	}
      else
	gelf_getrela (data, ndx, &rela);
      gelf_getsym (symdata, ELF64_R_SYM (rela.r_info), &sym);
      /* Relocations against section symbols are uninteresting in REL.  */
      if (dso->shdr[i].sh_type == SHT_REL && sym.st_value == 0)
	continue;
      /* Only consider relocations against .debug_str, .debug_line,
	 .debug_line_str, and .debug_abbrev.  */
      if (sym.st_shndx == 0 ||
	  (sym.st_shndx != debug_sections[DEBUG_STR].sec
	   && sym.st_shndx != debug_sections[DEBUG_LINE].sec
	   && sym.st_shndx != debug_sections[DEBUG_LINE_STR].sec
	   && sym.st_shndx != debug_sections[DEBUG_ABBREV].sec))
	continue;
      rela.r_addend += sym.st_value;
      rtype = ELF64_R_TYPE (rela.r_info);
      switch (dso->ehdr.e_machine)
	{
	case EM_SPARC:
	case EM_SPARC32PLUS:
	case EM_SPARCV9:
	  if (rtype != R_SPARC_32 && rtype != R_SPARC_UA32)
	    goto fail;
	  break;
	case EM_386:
	  if (rtype != R_386_32)
	    goto fail;
	  break;
	case EM_PPC:
	case EM_PPC64:
	  if (rtype != R_PPC_ADDR32 && rtype != R_PPC_UADDR32)
	    goto fail;
	  break;
	case EM_S390:
	  if (rtype != R_390_32)
	    goto fail;
	  break;
	case EM_IA_64:
	  if (rtype != R_IA64_SECREL32LSB)
	    goto fail;
	  break;
	case EM_X86_64:
	  if (rtype != R_X86_64_32)
	    goto fail;
	  break;
	case EM_ALPHA:
	  if (rtype != R_ALPHA_REFLONG)
	    goto fail;
	  break;
#if defined(EM_AARCH64) && defined(R_AARCH64_ABS32)
	case EM_AARCH64:
	  if (rtype != R_AARCH64_ABS32)
	    goto fail;
	  break;
#endif
	case EM_68K:
	  if (rtype != R_68K_32)
	    goto fail;
	  break;
#if defined(EM_RISCV) && defined(R_RISCV_32)
	case EM_RISCV:
	  if (rtype != R_RISCV_32)
	    goto fail;
	  break;
#endif
#if defined(EM_MCST_ELBRUS) && defined(R_E2K_32_ABS)
	case EM_MCST_ELBRUS:
	  if (rtype != R_E2K_32_ABS)
		  goto fail;
	  break;
#endif
	default:
	fail:
	  error (1, 0, "%s: Unhandled relocation %d at [%d] for %s section",
		 dso->filename, rtype, ndx, sec->name);
	}
      relend->ptr = sec->data
	+ (rela.r_offset - base);
      relend->addend = rela.r_addend;
      relend->ndx = ndx;
      ++(relend);
    }
  if (relbuf == relend)
    {
      free (relbuf);
      relbuf = NULL;
      relend = NULL;
    }
  else
    qsort (relbuf, relend - relbuf, sizeof (REL), rel_cmp);

  sec->relbuf = relbuf;
  sec->relend = relend;
  relptr = relbuf;
}

/* Updates SHT_RELA section associated with the given section based on
   the relbuf data. The relbuf data is freed at the end.  */
static void
update_rela_data (DSO *dso, struct debug_section *sec)
{
  Elf_Data *symdata;
  int relsec_ndx = sec->relsec;
  Elf_Data *data = elf_getdata (dso->scn[relsec_ndx], NULL);
  symdata = elf_getdata (dso->scn[dso->shdr[relsec_ndx].sh_link],
			 NULL);

  relptr = sec->relbuf;
  relend = sec->relend;
  while (relptr < relend)
    {
      GElf_Sym sym;
      GElf_Rela rela;
      int ndx = relptr->ndx;

      if (gelf_getrela (data, ndx, &rela) == NULL)
	error (1, 0, "Couldn't get relocation: %s",
	       elf_errmsg (-1));

      if (gelf_getsym (symdata, GELF_R_SYM (rela.r_info),
		       &sym) == NULL)
	error (1, 0, "Couldn't get symbol: %s", elf_errmsg (-1));

      rela.r_addend = relptr->addend - sym.st_value;

      if (gelf_update_rela (data, ndx, &rela) == 0)
	error (1, 0, "Couldn't update relocations: %s",
	       elf_errmsg (-1));

      ++relptr;
    }
  elf_flagdata (data, ELF_C_SET, ELF_F_DIRTY);

  free (sec->relbuf);
}

struct abbrev_attr
  {
    unsigned int attr;
    unsigned int form;
  };

struct abbrev_tag
  {
    unsigned int entry;
    unsigned int tag;
    int nattr;
    struct abbrev_attr attr[0];
  };

static hashval_t
abbrev_hash (const void *p)
{
  struct abbrev_tag *t = (struct abbrev_tag *)p;

  return t->entry;
}

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;
}

static void
abbrev_del (void *p)
{
  free (p);
}

static htab_t
read_abbrev (DSO *dso, unsigned char *ptr)
{
  htab_t h = htab_try_create (50, abbrev_hash, abbrev_eq, abbrev_del);
  unsigned int attr, form;
  struct abbrev_tag *t;
  int size;
  void **slot;

  if (h == NULL)
    {
no_memory:
      error (0, ENOMEM, "%s: Could not read .debug_abbrev", dso->filename);
      if (h)
        htab_delete (h);
      return NULL;
    }

  while ((attr = read_uleb128 (ptr)) != 0)
    {
      size = 10;
      t = malloc (sizeof (*t) + size * sizeof (struct abbrev_attr));
      if (t == NULL)
        goto no_memory;
      t->entry = attr;
      t->nattr = 0;
      slot = htab_find_slot (h, t, INSERT);
      if (slot == NULL)
        {
	  free (t);
	  goto no_memory;
        }
      if (*slot != NULL)
	{
	  error (0, 0, "%s: Duplicate DWARF abbreviation %d", dso->filename,
		 t->entry);
	  free (t);
	  htab_delete (h);
	  return NULL;
	}
      t->tag = read_uleb128 (ptr);
      ++ptr; /* skip children flag.  */
      while ((attr = read_uleb128 (ptr)) != 0)
        {
	  if (t->nattr == size)
	    {
	      struct abbrev_tag *orig_t = t;
	      size += 10;
	      t = realloc (t, sizeof (*t) + size * sizeof (struct abbrev_attr));
	      if (t == NULL)
		{
		  free (orig_t);
		  goto no_memory;
		}
	    }
	  form = read_uleb128 (ptr);
	  if (form == 2
	      || (form > DW_FORM_flag_present
		  && !(form == DW_FORM_ref_sig8
		       || form == DW_FORM_data16
		       || form == DW_FORM_line_strp
		       || form == DW_FORM_implicit_const
		       || form == DW_FORM_addrx
		       || form == DW_FORM_loclistx
		       || form == DW_FORM_rnglistx
		       || form == DW_FORM_addrx1
		       || form == DW_FORM_addrx2
		       || form == DW_FORM_addrx3
		       || form == DW_FORM_addrx4)))
	    {
	      error (0, 0, "%s: Unknown DWARF DW_FORM_0x%x", dso->filename,
		     form);
	      htab_delete (h);
	      return NULL;
	    }
	  if (form == DW_FORM_implicit_const)
	    {
	      /* It is SLEB128 but the value is dropped anyway.  */
	      read_uleb128 (ptr);
	    }

	  t->attr[t->nattr].attr = attr;
	  t->attr[t->nattr++].form = form;
        }
      if (read_uleb128 (ptr) != 0)
        {
	  error (0, 0, "%s: DWARF abbreviation does not end with 2 zeros",
		 dso->filename);
	  htab_delete (h);
	  return NULL;
        }
      *slot = t;
    }

  return h;
}

#define IS_DIR_SEPARATOR(c) ((c)=='/')

static char *
canonicalize_path (const char *s, char *d)
{
  char *rv = d;
  char *droot;

  if (IS_DIR_SEPARATOR (*s))
    {
      *d++ = *s++;
      if (IS_DIR_SEPARATOR (*s) && !IS_DIR_SEPARATOR (s[1]))
	{
	  /* Special case for "//foo" meaning a Posix namespace
	     escape.  */
	  *d++ = *s++;
	}
      while (IS_DIR_SEPARATOR (*s))
	s++;
    }
  droot = d;

  while (*s)
    {
      /* At this point, we're always at the beginning of a path
	 segment.  */

      if (s[0] == '.' && (s[1] == 0 || IS_DIR_SEPARATOR (s[1])))
	{
	  s++;
	  if (*s)
	    while (IS_DIR_SEPARATOR (*s))
	      ++s;
	}

      else if (s[0] == '.' && s[1] == '.'
	       && (s[2] == 0 || IS_DIR_SEPARATOR (s[2])))
	{
	  char *pre = d - 1; /* includes slash */
	  while (droot < pre && IS_DIR_SEPARATOR (*pre))
	    pre--;
	  if (droot <= pre && ! IS_DIR_SEPARATOR (*pre))
	    {
	      while (droot < pre && ! IS_DIR_SEPARATOR (*pre))
		pre--;
	      /* pre now points to the slash */
	      if (droot < pre)
		pre++;
	      if (pre + 3 == d && pre[0] == '.' && pre[1] == '.')
		{
		  *d++ = *s++;
		  *d++ = *s++;
		}
	      else
		{
		  d = pre;
		  s += 2;
		  if (*s)
		    while (IS_DIR_SEPARATOR (*s))
		      s++;
		}
	    }
	  else
	    {
	      *d++ = *s++;
	      *d++ = *s++;
	    }
	}
      else
	{
	  while (*s && ! IS_DIR_SEPARATOR (*s))
	    *d++ = *s++;
	}

      if (IS_DIR_SEPARATOR (*s))
	{
	  *d++ = *s++;
	  while (IS_DIR_SEPARATOR (*s))
	    s++;
	}
    }
  while (droot < d && IS_DIR_SEPARATOR (d[-1]))
    --d;
  if (d == rv)
    *d++ = '.';
  *d = 0;

  return rv;
}

/* Returns the rest of PATH if it starts with DIR_PREFIX, skipping any
   / path separators, or NULL if PATH doesn't start with
   DIR_PREFIX. Might return the empty string if PATH equals DIR_PREFIX
   (modulo trailing slashes). Never returns path starting with '/'.
   Note that DIR_PREFIX itself should NOT end with a '/'.  */
static const char *
skip_dir_prefix (const char *path, const char *dir_prefix)
{
  size_t prefix_len = strlen (dir_prefix);
  if (strncmp (path, dir_prefix, prefix_len) == 0)
    {
      path += prefix_len;
      /* Unless path == dir_prefix there should be at least one '/'
	 in the path (which we will skip).  Otherwise the path has
	 a different (longer) directory prefix.  */
      if (*path != '\0' && !IS_DIR_SEPARATOR (*path))
	return NULL;
      while (IS_DIR_SEPARATOR (path[0]))
	path++;
      return path;
    }

  return NULL;
}

/* Most strings will be in the existing debug string table. But to
   replace the base/dest directory prefix we need some new storage.
   Keep new strings somewhat close together for faster comparison and
   copying.  SIZE should be at least one (and includes space for the
   zero terminator). The returned pointer points to uninitialized
   data.  */
static char *
new_string_storage (struct strings *strings, size_t size)
{
  assert (size > 0);

  /* If the string is extra long just create a whole block for
     it. Normally strings are much smaller than STRMEMSIZE. */
  if (strings->last_block == NULL
      || size > STRMEMSIZE
      || strings->stridx > STRMEMSIZE
      || (STRMEMSIZE - strings->stridx) < size)
    {
      struct strmemblock *newblock = malloc (sizeof (struct strmemblock)
					     + MAX (STRMEMSIZE, size));
      if (newblock == NULL)
	return NULL;

      newblock->next = NULL;

      if (strings->blocks == NULL)
	strings->blocks = newblock;

      if (strings->last_block != NULL)
	strings->last_block->next = newblock;

      strings->last_block = newblock;
      strings->stridx = 0;
    }

  size_t stridx = strings->stridx;
  strings->stridx += size + 1;
  return &strings->last_block->memory[stridx];
}

/* Comparison function used for tsearch. */
static int
strent_compare (const void *a, const void *b)
{
  struct stridxentry *entry_a = (struct stridxentry *)a;
  struct stridxentry *entry_b = (struct stridxentry *)b;
  size_t idx_a = entry_a->idx;
  size_t idx_b = entry_b->idx;

  if (idx_a < idx_b)
    return -1;

  if (idx_a > idx_b)
    return 1;

  return 0;
}

/* Allocates and inserts a new entry for the old index if not yet
   seen.  Returns a stridxentry if the given index has not yet been
   seen and needs to be filled in with the associated string (either
   the original string or the replacement string). Returns NULL if the
   idx is already known. Use in phase 0 to add all strings seen. In
   phase 1 use string_find_entry instead to get existing entries. */
static struct stridxentry *
string_find_new_entry (struct strings *strings, size_t old_idx)
{
  /* Use next entry in the pool for lookup so we can use it directly
     if this is a new index. */
  struct stridxentry *entry;

  /* Keep entries close together to make key comparison fast. */
  if (strings->last_entries == NULL || strings->entryidx >= STRIDXENTRIES)
    {
      size_t entriessz = (sizeof (struct strentblock)
			  + (STRIDXENTRIES * sizeof (struct stridxentry)));
      struct strentblock *newentries = malloc (entriessz);
      if (newentries == NULL)
	error (1, errno, "Couldn't allocate new string entries block");
      else
	{
	  if (strings->entries == NULL)
	    strings->entries = newentries;

	  if (strings->last_entries != NULL)
	    strings->last_entries->next = newentries;

	  strings->last_entries = newentries;
	  strings->last_entries->next = NULL;
	  strings->entryidx = 0;
	}
    }

  entry = &strings->last_entries->entry[strings->entryidx];
  entry->idx = old_idx;
  struct stridxentry **tres = tsearch (entry, &strings->strent_root,
				       strent_compare);
  if (tres == NULL)
    error (1, ENOMEM, "Couldn't insert new strtab idx");
  else if (*tres == entry)
    {
      /* idx not yet seen, must add actual str.  */
      strings->entryidx++;
      return entry;
    }

  return NULL; /* We already know about this idx, entry already complete. */
}

static struct stridxentry *
string_find_entry (struct strings *strings, size_t old_idx)
{
  struct stridxentry **ret;
  struct stridxentry key;
  key.idx = old_idx;
  ret = tfind (&key, &strings->strent_root, strent_compare);
  assert (ret != NULL); /* Can only happen for a bad/non-existing old_idx. */
  return *ret;
}

/* Adds a string_idx_entry given an index into the old/existing string
   table. Should be used in phase 0. Does nothing if the index was
   already registered. Otherwise it checks the string associated with
   the index. If the old string doesn't start with base_dir an entry
   will be recorded for the index with the same string. Otherwise a
   string will be recorded where the base_dir prefix will be replaced
   by dest_dir. Returns true if this is a not yet seen index and there
   a replacement file string has been recorded for it, otherwise
   returns false.  */
static bool
record_file_string_entry_idx (bool line_strp, DSO *dso, size_t old_idx)
{
  struct strings *strings = line_strp ? &dso->debug_line_str : &dso->debug_str;
  bool ret = false;
  struct stridxentry *entry = string_find_new_entry (strings, old_idx);
  if (entry != NULL)
    {
      debug_section *sec = &debug_sections[line_strp
					   ? DEBUG_LINE_STR : DEBUG_STR];
      if (old_idx >= sec->size)
	error (1, 0, "Bad string pointer index %zd (%s)", old_idx, sec->name);

      Strent *strent;
      const char *old_str = (char *)sec->data + old_idx;
      const char *file = skip_dir_prefix (old_str, base_dir);
      if (file == NULL)
	{
	  /* Just record the existing string.  */
	  strent = strtab_add_len (strings->str_tab, old_str,
				   strlen (old_str) + 1);
	}
      else
	{
	  /* Create and record the altered file path. */
	  size_t dest_len = strlen (dest_dir);
	  size_t file_len = strlen (file);
	  size_t nsize = dest_len + 1; /* + '\0' */
	  if (file_len > 0)
	    nsize += 1 + file_len;     /* + '/' */
	  char *nname = new_string_storage (strings, nsize);
	  if (nname == NULL)
	    error (1, ENOMEM, "Couldn't allocate new string storage");
	  memcpy (nname, dest_dir, dest_len);
	  if (file_len > 0)
	    {
	      nname[dest_len] = '/';
	      memcpy (nname + dest_len + 1, file, file_len + 1);
	    }
	  else
	    nname[dest_len] = '\0';

	  strent = strtab_add_len (strings->str_tab, nname, nsize);
	  ret = true;
	}
      if (strent == NULL)
	error (1, ENOMEM, "Could not create new string table entry");
      else
	entry->entry = strent;
    }

  return ret;
}

/* Same as record_new_string_file_string_entry_idx but doesn't replace
   base_dir with dest_dir, just records the existing string associated
   with the index. */
static void
record_existing_string_entry_idx (bool line_strp, DSO *dso, size_t old_idx)
{
  struct strings *strings = line_strp ? &dso->debug_line_str : &dso->debug_str;
  struct stridxentry *entry = string_find_new_entry (strings, old_idx);
  if (entry != NULL)
    {
      debug_section *sec = &debug_sections[line_strp
					   ? DEBUG_LINE_STR : DEBUG_STR];
      if (old_idx >= sec->size)
	error (1, 0, "Bad string pointer index %zd (%s)", old_idx, sec->name);

      const char *str = (char *)sec->data + old_idx;
      Strent *strent = strtab_add_len (strings->str_tab,
				       str, strlen (str) + 1);
      if (strent == NULL)
	error (1, ENOMEM, "Could not create new string table entry");
      else
	entry->entry = strent;
    }
}

static void
setup_strings (struct strings *strings)
{
  strings->str_tab = strtab_init (false);
  strings->str_buf = NULL;
  strings->blocks = NULL;
  strings->last_block = NULL;
  strings->entries = NULL;
  strings->last_entries = NULL;
  strings->strent_root = NULL;
}

/* Noop for tdestroy. */
static void free_node (void *p __attribute__((__unused__))) { }

static void
destroy_strings (struct strings *strings)
{
  struct strmemblock *smb = strings->blocks;
  while (smb != NULL)
    {
      void *old = smb;
      smb = smb->next;
      free (old);
    }

  struct strentblock *emb = strings->entries;
  while (emb != NULL)
    {
      void *old = emb;
      emb = emb->next;
      free (old);
    }

  strtab_free (strings->str_tab);
  tdestroy (strings->strent_root, &free_node);
  free (strings->str_buf);
}

/* The minimum number of line tables we pre-allocate. */
#define MIN_LINE_TABLES 64

/* Gets a line_table at offset. Returns true if not yet know and
   successfully read, false otherwise.  Sets *table to NULL and
   outputs a warning if there was a problem reading the table at the
   given offset.  */
static bool
get_line_table (DSO *dso, size_t off, struct line_table **table)
{
  struct debug_lines *lines = &dso->lines;
  /* Assume there aren't that many, just do a linear search.  The
     array is probably already sorted because the stmt_lists are
     probably inserted in order. But we cannot rely on that (maybe we
     should check that to make searching quicker if possible?).  Once
     we have all line tables for phase 1 (rewriting) we do explicitly
     sort the array.*/
  for (int i = 0; i < lines->used; i++)
    if (lines->table[i].old_idx == off)
      {
	*table = &lines->table[i];
	return false;
      }

  if (lines->size == lines->used)
    {
      struct line_table *new_table = realloc (lines->table,
					      (sizeof (struct line_table)
					       * (lines->size
						  + MIN_LINE_TABLES)));
      if (new_table == NULL)
	{
	  error (0, ENOMEM, "Couldn't add more debug_line tables");
	  *table = NULL;
	  return false;
	}
      lines->table = new_table;
      lines->size += MIN_LINE_TABLES;
    }

  struct line_table *t = &lines->table[lines->used];
  *table = NULL;

  t->old_idx = off;
  t->new_idx = off;
  t->size_diff = 0;
  t->replace_dirs = false;
  t->replace_files = false;

  unsigned char *ptr = debug_sections[DEBUG_LINE].data;
  unsigned char *endsec = ptr + debug_sections[DEBUG_LINE].size;
  if (ptr == NULL)
    {
      error (0, 0, "%s: No .line_table section", dso->filename);
      return false;
    }

  if (off > debug_sections[DEBUG_LINE].size)
    {
      error (0, 0, "%s: Invalid .line_table offset 0x%zx",
	     dso->filename, off);
      return false;
    }
  ptr += off;

  /* unit_length */
  unsigned char *endcu = ptr + 4;
  t->unit_length = read_32 (ptr);
  endcu += t->unit_length;
  if (endcu == ptr + 0xffffffff)
    {
      error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
      return false;
    }

  if (endcu > endsec)
    {
      error (0, 0, "%s: .debug_line CU does not fit into section",
	     dso->filename);
      return false;
    }

  /* version */
  t->version = read_16 (ptr);
  if (t->version != 2 && t->version != 3 && t->version != 4 && t->version != 5)
    {
      error (0, 0, "%s: DWARF version %d unhandled", dso->filename,
	     t->version);
      return false;
    }

  if (t->version >= 5)
    {
      /* address_size */
      assert (ptr_size != 0);
      if (ptr_size != read_8 (ptr))
	{
	  error (0, 0, "%s: .debug_line address size differs from .debug_info",
		 dso->filename);
	  return false;
	}

      /* segment_selector_size */
      (void) read_8 (ptr);
    }

  /* header_length */
  unsigned char *endprol = ptr + 4;
  t->header_length = read_32 (ptr);
  endprol += t->header_length;
  if (endprol > endcu)
    {
      error (0, 0, "%s: .debug_line CU prologue does not fit into CU",
	     dso->filename);
      return false;
    }

  /* min instr len */
  t->min_instr_len = *ptr++;

  /* max op per instr, if version >= 4 */
  if (t->version >= 4)
    t->max_op_per_instr = *ptr++;

  /* default is stmt */
  t->default_is_stmt = *ptr++;

  /* line base */
  t->line_base = (*(int8_t *)ptr++);

  /* line range */
  t->line_range = *ptr++;

  /* opcode base */
  t->opcode_base = *ptr++;

  if (ptr + t->opcode_base - 1 >= endcu)
    {
      error (0, 0, "%s: .debug_line opcode table does not fit into CU",
	     dso->filename);
      return false;
    }
  lines->used++;
  *table = t;
  return true;
}

static int dirty_elf;
static void
dirty_section (unsigned int sec)
{
  for (struct debug_section *secp = &debug_sections[sec]; secp != NULL;
       secp = secp->next)
    elf_flagdata (secp->elf_data, ELF_C_SET, ELF_F_DIRTY);
  dirty_elf = 1;
}

static int
line_table_cmp (const void *a, const void *b)
{
  struct line_table *ta = (struct line_table *) a;
  struct line_table *tb = (struct line_table *) b;

  if (ta->old_idx < tb->old_idx)
    return -1;

  if (ta->old_idx > tb->old_idx)
    return 1;

  return 0;
}


/* Called after phase zero (which records all adjustments needed for
   the line tables referenced from debug_info) and before phase one
   starts (phase one will adjust the .debug_line section stmt
   references using the updated data structures). */
static void
edit_dwarf2_line (DSO *dso)
{
  Elf_Data *linedata = debug_sections[DEBUG_LINE].elf_data;
  int linendx = debug_sections[DEBUG_LINE].sec;
  Elf_Scn *linescn = dso->scn[linendx];
  unsigned char *old_buf = linedata->d_buf;

  /* Out with the old. */
  linedata->d_size = 0;

  /* In with the new. */
  linedata = elf_newdata (linescn);

  dso->lines.line_buf = malloc (dso->lines.debug_lines_len);
  if (dso->lines.line_buf == NULL)
    error (1, ENOMEM, "No memory for new .debug_line table (0x%zx bytes)",
	   dso->lines.debug_lines_len);

  linedata->d_size = dso->lines.debug_lines_len;
  linedata->d_buf = dso->lines.line_buf;
  debug_sections[DEBUG_LINE].data = linedata->d_buf;
  debug_sections[DEBUG_LINE].size = linedata->d_size;
  debug_sections[DEBUG_LINE].elf_data = linedata;

  /* Make sure the line tables are sorted on the old index. */
  qsort (dso->lines.table, dso->lines.used, sizeof (struct line_table),
	 line_table_cmp);

  unsigned char *ptr = linedata->d_buf;
  for (int ldx = 0; ldx < dso->lines.used; ldx++)
    {
      struct line_table *t = &dso->lines.table[ldx];
      unsigned char *optr = old_buf + t->old_idx;
      t->new_idx = ptr - (unsigned char *) linedata->d_buf;

      /* Just copy the whole table if nothing needs replacing. */
      if (! t->replace_dirs && ! t->replace_files)
	{
	  assert (t->size_diff == 0);
	  memcpy (ptr, optr, t->unit_length + 4);
	  ptr += t->unit_length + 4;
	  continue;
	}

      /* Header fields. */
      write_32 (ptr, t->unit_length + t->size_diff);
      write_16 (ptr, t->version);
      write_32 (ptr, t->header_length + t->size_diff);
      write_8 (ptr, t->min_instr_len);
      if (t->version >= 4)
	write_8 (ptr, t->max_op_per_instr);
      write_8 (ptr, t->default_is_stmt);
      write_8 (ptr, t->line_base);
      write_8 (ptr, t->line_range);
      write_8 (ptr, t->opcode_base);

      optr += (4 /* unit len */
	       + 2 /* version */
	       + 4 /* header len */
	       + 1 /* min instr len */
	       + (t->version >= 4) /* max op per instr, if version >= 4 */
	       + 1 /* default is stmt */
	       + 1 /* line base */
	       + 1 /* line range */
	       + 1); /* opcode base */

      /* opcode len table. */
      memcpy (ptr, optr, t->opcode_base - 1);
      optr += t->opcode_base - 1;
      ptr += t->opcode_base - 1;

      /* directory table. We need to find the end (start of file
	 table) anyway, so loop over all dirs, even if replace_dirs is
	 false. */
      while (*optr != 0)
	{
	  const char *dir = (const char *) optr;
	  const char *file_path = NULL;
	  if (t->replace_dirs)
	    {
	      file_path = skip_dir_prefix (dir, base_dir);
	      if (file_path != NULL)
		{
		  size_t dest_len = strlen (dest_dir);
		  size_t file_len = strlen (file_path);
		  memcpy (ptr, dest_dir, dest_len);
		  ptr += dest_len;
		  if (file_len > 0)
		    {
		      *ptr++ = '/';
		      memcpy (ptr, file_path, file_len);
		      ptr += file_len;
		    }
		  *ptr++ = '\0';
		}
	    }
	  if (file_path == NULL)
	    {
	      size_t dir_len = strlen (dir);
	      memcpy (ptr, dir, dir_len + 1);
	      ptr += dir_len + 1;
	    }

	  optr = (unsigned char *) strchr (dir, 0) + 1;
	}
      optr++;
      *ptr++ = '\0';

      /* file table */
      if (t->replace_files)
	{
	  while (*optr != 0)
	    {
	      const char *file = (const char *) optr;
	      const char *file_path = NULL;
	      if (t->replace_files)
		{
		  file_path = skip_dir_prefix (file, base_dir);
		  if (file_path != NULL)
		    {
		      size_t dest_len = strlen (dest_dir);
		      size_t file_len = strlen (file_path);
		      memcpy (ptr, dest_dir, dest_len);
		      ptr += dest_len;
		      if (file_len > 0)
			{
			  *ptr++ = '/';
			  memcpy (ptr, file_path, file_len);
			  ptr += file_len;
			}
		      *ptr++ = '\0';
		    }
		}
	      if (file_path == NULL)
		{
		  size_t file_len = strlen (file);
		  memcpy (ptr, file, file_len + 1);
		  ptr += file_len + 1;
		}

	      optr = (unsigned char *) strchr (file, 0) + 1;

	      /* dir idx, time, len */
	      uint32_t dir_idx = read_uleb128 (optr);
	      write_uleb128 (ptr, dir_idx);
	      uint32_t time = read_uleb128 (optr);
	      write_uleb128 (ptr, time);
	      uint32_t len = read_uleb128 (optr);
	      write_uleb128 (ptr, len);
	    }
	  optr++;
	  *ptr++ = '\0';
	}

      /* line number program (and file table if not copied above). */
      size_t remaining = (t->unit_length + 4
			  - (optr - (old_buf + t->old_idx)));
      memcpy (ptr, optr, remaining);
      ptr += remaining;
    }
}

/* Record or adjust (according to phase) DW_FORM_strp or DW_FORM_line_strp.  */
static void
edit_strp (DSO *dso, bool line_strp, unsigned char *ptr, int phase,
	   bool handled_strp)
{
  unsigned char *ptr_orig = ptr;

  /* In the first pass we collect all strings, in the
     second we put the new references back (if there are
     any changes).  */
  if (phase == 0)
    {
      /* handled_strp is set for attributes referring to
	 files. If it is set the string is already
	 recorded. */
      if (! handled_strp)
	{
	  size_t idx = do_read_32_relocated (ptr);
	  record_existing_string_entry_idx (line_strp, dso, idx);
	}
    }
  else if (line_strp
	   ? need_line_strp_update : need_strp_update) /* && phase == 1 */
    {
      struct stridxentry *entry;
      size_t idx, new_idx;
      struct strings *strings = (line_strp
				 ? &dso->debug_line_str : &dso->debug_str);
      idx = do_read_32_relocated (ptr);
      entry = string_find_entry (strings, idx);
      new_idx = strent_offset (entry->entry);
      do_write_32_relocated (ptr, new_idx);
    }

  assert (ptr == ptr_orig);
}

/* Adjust *PTRP after the current *FORMP, update *FORMP for FORM_INDIRECT.  */
static enum { FORM_OK, FORM_ERROR, FORM_INDIRECT }
skip_form (DSO *dso, uint32_t *formp, unsigned char **ptrp)
{
  size_t len = 0;

  switch (*formp)
    {
    case DW_FORM_ref_addr:
      if (cu_version == 2)
	*ptrp += ptr_size;
      else
	*ptrp += 4;
      break;
    case DW_FORM_flag_present:
    case DW_FORM_implicit_const:
      break;
    case DW_FORM_addr:
      *ptrp += ptr_size;
      break;
    case DW_FORM_ref1:
    case DW_FORM_flag:
    case DW_FORM_data1:
    case DW_FORM_strx1:
    case DW_FORM_addrx1:
      ++*ptrp;
      break;
    case DW_FORM_ref2:
    case DW_FORM_data2:
    case DW_FORM_strx2:
    case DW_FORM_addrx2:
      *ptrp += 2;
      break;
    case DW_FORM_strx3:
    case DW_FORM_addrx3:
      *ptrp += 3;
      break;
    case DW_FORM_ref4:
    case DW_FORM_data4:
    case DW_FORM_strx4:
    case DW_FORM_addrx4:
    case DW_FORM_sec_offset:
      *ptrp += 4;
      break;
    case DW_FORM_ref8:
    case DW_FORM_data8:
    case DW_FORM_ref_sig8:
      *ptrp += 8;
      break;
    case DW_FORM_data16:
      *ptrp += 16;
      break;
    case DW_FORM_sdata:
    case DW_FORM_ref_udata:
    case DW_FORM_udata:
    case DW_FORM_strx:
    case DW_FORM_loclistx:
    case DW_FORM_rnglistx:
    case DW_FORM_addrx:
      read_uleb128 (*ptrp);
      break;
    case DW_FORM_strp:
    case DW_FORM_line_strp:
      *ptrp += 4;
      break;
    case DW_FORM_string:
      *ptrp = (unsigned char *) strchr ((char *)*ptrp, '\0') + 1;
      break;
    case DW_FORM_indirect:
      *formp = read_uleb128 (*ptrp);
      return FORM_INDIRECT;
    case DW_FORM_block1:
      len = *(*ptrp)++;
      break;
    case DW_FORM_block2:
      len = read_16 (*ptrp);
      *formp = DW_FORM_block1;
      break;
    case DW_FORM_block4:
      len = read_32 (*ptrp);
      *formp = DW_FORM_block1;
      break;
    case DW_FORM_block:
    case DW_FORM_exprloc:
      len = read_uleb128 (*ptrp);
      *formp = DW_FORM_block1;
      assert (len < UINT_MAX);
      break;
    default:
      error (0, 0, "%s: Unknown DWARF DW_FORM_0x%x", dso->filename, *formp);
      return FORM_ERROR;
    }

  if (*formp == DW_FORM_block1)
    *ptrp += len;

  return FORM_OK;
}

/* Part of read_dwarf2_line processing DWARF-4.  */
static bool
read_dwarf4_line (DSO *dso, unsigned char *ptr, char *comp_dir,
		  struct line_table *table)
{
  unsigned char **dirt;
  uint32_t value, dirt_cnt;
  size_t comp_dir_len = !comp_dir ? 0 : strlen (comp_dir);
  unsigned char *dir = ptr;

  /* dir table: */
  value = 1;
  while (*ptr != 0)
    {
      if (base_dir && dest_dir)
	{
	  /* Do we need to replace any of the dirs? Calculate new size. */
	  const char *file_path = skip_dir_prefix ((const char *)ptr,
						   base_dir);
	  if (file_path != NULL)
	    {
	      size_t old_size = strlen ((const char *)ptr) + 1;
	      size_t file_len = strlen (file_path);
	      size_t new_size = strlen (dest_dir) + 1;
	      if (file_len > 0)
		new_size += 1 + file_len;
	      table->size_diff += (new_size - old_size);
	      table->replace_dirs = true;
	    }
	}

      ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
      ++value;
    }

  dirt = (unsigned char **) alloca (value * sizeof (unsigned char *));
  dirt[0] = (unsigned char *) ".";
  dirt_cnt = 1;
  ptr = dir;
  while (*ptr != 0)
    {
      dirt[dirt_cnt++] = ptr;
      ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
    }
  ptr++;

  /* file table: */
  while (*ptr != 0)
    {
      char *s, *file;
      size_t file_len, dir_len;

      file = (char *) ptr;
      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 false;
	}
      file_len = strlen (file);
      if (base_dir && dest_dir)
	{
	  /* Do we need to replace any of the files? Calculate new size. */
	  const char *file_path = skip_dir_prefix (file, base_dir);
	  if (file_path != NULL)
	    {
	      size_t old_size = file_len + 1;
	      size_t file_len = strlen (file_path);
	      size_t new_size = strlen (dest_dir) + 1;
	      if (file_len > 0)
		new_size += 1 + file_len;
	      table->size_diff += (new_size - old_size);
	      table->replace_files = true;
	    }
	}
      dir_len = strlen ((char *)dirt[value]);
      s = malloc (comp_dir_len + 1 + file_len + 1 + dir_len + 1);
      if (s == NULL)
	{
	  error (0, ENOMEM, "%s: Reading file table", dso->filename);
	  return false;
	}
      if (*file == '/')
	{
	  memcpy (s, file, file_len + 1);
	}
      else if (*dirt[value] == '/')
	{
	  memcpy (s, dirt[value], dir_len);
	  s[dir_len] = '/';
	  memcpy (s + dir_len + 1, file, file_len + 1);
	}
      else
	{
	  char *p = s;
	  if (comp_dir_len != 0)
	    {
	      memcpy (s, comp_dir, comp_dir_len);
	      s[comp_dir_len] = '/';
	      p += comp_dir_len + 1;
	    }
	  memcpy (p, dirt[value], dir_len);
	  p[dir_len] = '/';
	  memcpy (p + dir_len + 1, file, file_len + 1);
	}
      canonicalize_path (s, s);
      if (list_file_fd != -1)
	{
	  const char *p = NULL;
	  if (base_dir == NULL)
	    p = s;
	  else
	    {
	      p = skip_dir_prefix (s, base_dir);
	      if (p == NULL && dest_dir != NULL)
		p = skip_dir_prefix (s, dest_dir);
	    }

	  if (p)
	    {
	      size_t size = strlen (p) + 1;
	      while (size > 0)
		{
		  ssize_t ret = write (list_file_fd, p, size);
		  if (ret == -1)
		    error (1, errno, "Could not write to '%s'", list_file);
		  size -= ret;
		  p += ret;
		}
	    }
	}

      free (s);

      read_uleb128 (ptr);
      read_uleb128 (ptr);
    }

  return true;
}

/* Called by read_dwarf5_line first for directories and then file
   names as they both have the same format.  */
static bool
read_dwarf5_line_entries (DSO *dso, unsigned char **ptrp,
			  struct line_table *table, int phase,
			  char ***dirs, int *ndir,
			  const char *entry_name)
{
  /* directory_entry_format_count */
  /* file_name_entry_format_count */
  unsigned format_count = read_8 (*ptrp);

  unsigned char *formats = *ptrp;

  /* directory_entry_format */
  /* file_name_entry_format */
  for (unsigned formati = 0; formati < format_count; ++formati)
    {
      read_uleb128 (*ptrp);
      read_uleb128 (*ptrp);
    }

  /* directories_count */
  /* file_names_count */
  unsigned entry_count = read_uleb128 (*ptrp);

  bool collecting_dirs = phase == 0 && *dirs == NULL;
  bool writing_files = phase == 0 && *dirs != NULL;
  if (collecting_dirs)
    {
      *ndir = entry_count;
      *dirs = malloc (entry_count * sizeof (char *));
      if (*dirs == NULL)
	error (1, errno, "%s: Could not allocate debug_line dirs",
	       dso->filename);
    }

  /* directories */
  /* file_names */
  for (unsigned entryi = 0; entryi < entry_count; ++entryi)
    {
      char *dir = NULL;
      char *file = NULL;;
      unsigned char *format_ptr = formats;
      for (unsigned formati = 0; formati < format_count; ++formati)
	{
	  unsigned lnct = read_uleb128 (format_ptr);
	  unsigned form = read_uleb128 (format_ptr);
	  bool handled_form = false;
	  bool handled_strp = false;
	  bool line_strp = form == DW_FORM_line_strp;
	  if (lnct == DW_LNCT_path)
	    {
	      switch (form)
		{
		case DW_FORM_strp:
		case DW_FORM_line_strp:
		  if (phase == 0)
		    {
		      size_t idx = do_read_32_relocated (*ptrp);
		      if (dest_dir)
			{
			  if (record_file_string_entry_idx (line_strp, dso,
							    idx))
			    {
			      if (line_strp)
				need_line_strp_update = true;
			      else
				need_strp_update = true;
			    }
			}
		      handled_strp = true;
		      if (collecting_dirs || writing_files)
			{
			  debug_section *sec = &debug_sections[line_strp
                                           ? DEBUG_LINE_STR : DEBUG_STR];
			  if (collecting_dirs)
			    dir = (char *)sec->data + idx;
			  if (writing_files)
			    file = (char *)sec->data + idx;
			}
		    }
		  break;
		default:
		  error (0, 0, "%s: Unsupported "
			 ".debug_line %s %u path DW_FORM_0x%x",
			 dso->filename, entry_name, entryi, form);
		  return false;
		}
	    }
	  if (writing_files && lnct == DW_LNCT_directory_index)
	    {
	      int dirndx;
	      switch (form)
		{
		case DW_FORM_udata:
		  handled_form = true;
		  dirndx = read_uleb128 (*ptrp);
		  break;
		case DW_FORM_data1:
		  dirndx = **ptrp;
		  break;
		case DW_FORM_data2:
		  dirndx = do_read_16 (*ptrp);
		  break;
		case DW_FORM_data4:
		  dirndx = do_read_32 (*ptrp);
		  break;
		default:
		  error (0, 0, "%s: Unsupported "
			 ".debug_line %s %u dirndx DW_FORM_0x%x",
			 dso->filename, entry_name, entryi, form);
		  return false;
		}

	      if (dirndx > *ndir)
		{
		  error (0, 0, "%s: Bad dir number %u in .debug_line %s",
			 dso->filename, entryi, entry_name);
		  return false;
		}
	      dir = (*dirs)[dirndx];
	    }

	  switch (form)
	    {
	    case DW_FORM_strp:
	    case DW_FORM_line_strp:
	      edit_strp (dso, line_strp, *ptrp, phase, handled_strp);
	      break;
	    }

	  if (!handled_form)
	    {
	      switch (skip_form (dso, &form, ptrp))
		{
		case FORM_OK:
		  break;
		case FORM_ERROR:
		  return false;
		case FORM_INDIRECT:
		  error (0, 0, "%s: Unsupported "
			 ".debug_line %s %u DW_FORM_indirect",
			 dso->filename, entry_name, entryi);
		  return false;
		}
	    }
	}

      if (collecting_dirs)
	(*dirs)[entryi] = dir;

      if (writing_files)
	{
	  char *comp_dir = (*dirs)[0];
	  size_t comp_dir_len = !comp_dir ? 0 : strlen(comp_dir);
	  size_t file_len = strlen (file);
	  size_t dir_len = strlen (dir);

	  char *s = malloc (comp_dir_len + 1 + file_len + 1 + dir_len + 1);
	  if (s == NULL)
	    {
	      error (0, ENOMEM, "%s: Reading file table", dso->filename);
	      return false;
	    }
	  if (file[0] == '/')
	    {
	      memcpy (s, file, file_len + 1);
	    }
	  else if (dir[0] == '/')
	    {
	      memcpy (s, dir, dir_len);
	      s[dir_len] = '/';
	      memcpy (s + dir_len + 1, file, file_len + 1);
	    }
	  else
	    {
	      char *p = s;
	      if (comp_dir_len != 0)
		{
		  memcpy (s, comp_dir, comp_dir_len);
		  s[comp_dir_len] = '/';
		  p += comp_dir_len + 1;
		}
	      memcpy (p, dir, dir_len);
	      p[dir_len] = '/';
	      memcpy (p + dir_len + 1, file, file_len + 1);
	    }
	  canonicalize_path (s, s);
	  if (list_file_fd != -1)
	    {
	      const char *p = NULL;
	      if (base_dir == NULL)
		p = s;
	      else
		{
		  p = skip_dir_prefix (s, base_dir);
		  if (p == NULL && dest_dir != NULL)
		    p = skip_dir_prefix (s, dest_dir);
		}

	      if (p)
		{
		  size_t size = strlen (p) + 1;
		  while (size > 0)
		    {
		      ssize_t ret = write (list_file_fd, p, size);
		      if (ret == -1)
			error (1, errno, "Could not write to '%s'", list_file);
		      size -= ret;
		      p += ret;
		    }
		}
	    }

	  free (s);
	}
    }

  return true;
}

/* Part of read_dwarf2_line processing DWARF-5.  */
static bool
read_dwarf5_line (DSO *dso, unsigned char *ptr, struct line_table *table,
		  int phase)
{
  char **dirs = NULL;
  int ndir;
  /* Skip header.  */
  ptr += (4 /* unit len */
          + 2 /* version */
          + (table->version < 5 ? 0 : 0
             + 1 /* address_size */
             + 1 /* segment_selector*/)
          + 4 /* header len */
          + 1 /* min instr len */
          + (table->version >= 4) /* max op per instr, if version >= 4 */
          + 1 /* default is stmt */
          + 1 /* line base */
          + 1 /* line range */
          + 1 /* opcode base */
          + table->opcode_base - 1); /* opcode len table */

  bool retval = (read_dwarf5_line_entries (dso, &ptr, table, phase,
					   &dirs, &ndir, "directory")
		 && read_dwarf5_line_entries (dso, &ptr, table, phase,
					      &dirs, &ndir, "file name"));
  free (dirs);
  return retval;
}

/* Called during phase zero for each debug_line table referenced from
   .debug_info.  Outputs all source files seen and records any
   adjustments needed in the debug_list data structures. Returns true
   if line_table needs to be rewrite either the dir or file paths. */
static bool
read_dwarf2_line (DSO *dso, uint32_t off, char *comp_dir)
{
  unsigned char *ptr;
  struct line_table *table;

  if (get_line_table (dso, off, &table) == false
      || table == NULL)
    return false;

  /* Skip to the directory table. The rest of the header has already
     been read and checked by get_line_table. */
  ptr = debug_sections[DEBUG_LINE].data + off;
  ptr += (4 /* unit len */
	  + 2 /* version */
	  + (table->version < 5 ? 0 : 0
	     + 1 /* address_size */
	     + 1 /* segment_selector*/)
	  + 4 /* header len */
	  + 1 /* min instr len */
	  + (table->version >= 4) /* max op per instr, if version >= 4 */
	  + 1 /* default is stmt */
	  + 1 /* line base */
	  + 1 /* line range */
	  + 1 /* opcode base */
	  + table->opcode_base - 1); /* opcode len table */

  /* DWARF version 5 line tables won't change size. But they might need
     [line]strp recording/updates. Handle that part later.  */
  if (table->version < 5)
    {
      if (! read_dwarf4_line (dso, ptr, comp_dir, table))
	return false;
    }

  dso->lines.debug_lines_len += 4 + table->unit_length + table->size_diff;
  return table->replace_dirs || table->replace_files;
}

/* Called during phase one, after the table has been sorted. */
static size_t
find_new_list_offs (struct debug_lines *lines, size_t idx)
{
  struct line_table key;
  key.old_idx = idx;
  struct line_table *table = bsearch (&key, lines->table,
				      lines->used,
				      sizeof (struct line_table),
				      line_table_cmp);
  return table->new_idx;
}

/* Read DW_FORM_strp or DW_FORM_line_strp collecting compilation directory.  */
static void
edit_attributes_str_comp_dir (bool line_strp, DSO *dso, unsigned char **ptrp,
			      int phase, char **comp_dirp, bool *handled_strpp)
{
  const char *dir;
  size_t idx = do_read_32_relocated (*ptrp);
  /* In phase zero we collect the comp_dir.  */
  if (phase == 0)
    {
      debug_section *sec = &debug_sections[line_strp
					   ? DEBUG_LINE_STR : DEBUG_STR];
      if (sec->data == NULL || idx >= sec->size)
	error (1, 0, "%s: Bad string pointer index %zd for comp_dir (%s)",
	       dso->filename, idx, sec->name);
      dir = (char *) sec->data + idx;

      free (*comp_dirp);
      *comp_dirp = strdup (dir);
    }

  if (dest_dir != NULL && phase == 0)
    {
      if (record_file_string_entry_idx (line_strp, dso, idx))
	{
	  if (line_strp)
	    need_line_strp_update = true;
	  else
	    need_strp_update = true;
	}
      *handled_strpp = true;
    }
}

/* This scans the attributes of one DIE described by the given abbrev_tag.
   PTR points to the data in the debug_info. It will be advanced till all
   abbrev data is consumed. In phase zero data is collected, in phase one
   data might be replaced/updated.  */
static unsigned char *
edit_attributes (DSO *dso, unsigned char *ptr, struct abbrev_tag *t, int phase)
{
  int i;
  uint32_t list_offs;
  int found_list_offs;
  char *comp_dir;

  comp_dir = NULL;
  list_offs = 0;
  found_list_offs = 0;
  for (i = 0; i < t->nattr; ++i)
    {
      uint32_t form = t->attr[i].form;
      while (1)
	{
	  /* Whether we already handled a string as file for this
	     attribute.  If we did then we don't need to handle/record
	     it again when handling the DW_FORM_strp later. */
	  bool handled_strp = false;

	  /* A stmt_list points into the .debug_line section.  In
	     phase zero record all offsets. Then in phase one replace
	     them with the new offsets if we rewrote the line
	     tables.  */
	  if (t->attr[i].attr == DW_AT_stmt_list)
	    {
	      if (form == DW_FORM_data4
		  || form == DW_FORM_sec_offset)
		{
		  list_offs = do_read_32_relocated (ptr);
		  if (phase == 0)
		    found_list_offs = 1;
		  else if (need_stmt_update) /* phase one */
		    {
		      size_t idx, new_idx;
		      idx = do_read_32_relocated (ptr);
		      new_idx = find_new_list_offs (&dso->lines, idx);
		      do_write_32_relocated (ptr, new_idx);
		    }
		}
	    }

	  /* DW_AT_comp_dir is the current working directory. */
	  if (t->attr[i].attr == DW_AT_comp_dir)
	    {
	      if (form == DW_FORM_string)
		{
		  free (comp_dir);
		  comp_dir = strdup ((char *)ptr);

		  if (dest_dir)
		    {
		      /* In phase zero we are just collecting dir/file
			 names and check whether any need to be
			 adjusted. If so, in phase one we replace
			 those dir/files.  */
		      const char *file = skip_dir_prefix (comp_dir, base_dir);
		      if (file != NULL && phase == 0)
			need_string_replacement = true;
		      else if (file != NULL && phase == 1)
			{
			  size_t orig_len = strlen (comp_dir);
			  size_t dest_len = strlen (dest_dir);
			  size_t file_len = strlen (file);
			  size_t new_len = dest_len;
			  if (file_len > 0)
			    new_len += 1 + file_len; /* + '/' */

			  /* We don't want to rewrite the whole
			     debug_info section, so we only replace
			     the comp_dir with something equal or
			     smaller, possibly adding some slashes
			     at the end of the new compdir.  This
			     normally doesn't happen since most
			     producers will use DW_FORM_strp which is
			     more efficient.  */
			  if (orig_len < new_len)
			    error (0, 0, "Warning, not replacing comp_dir "
				   "'%s' prefix ('%s' -> '%s') encoded as "
				   "DW_FORM_string. "
				   "Replacement too large.",
				   comp_dir, base_dir, dest_dir);
			  else
			    {
			      /* Add zero (if no file part), one or more
				 slashes in between the new dest_dir and the
				 file name to fill up all space (replacement
				 DW_FORM_string must be of the same length).
				 We don't need to copy the old file name (if
				 any) or the zero terminator, because those
				 are already at the end of the string.  */
			      memcpy (ptr, dest_dir, dest_len);
			      memset (ptr + dest_len, '/',
				      orig_len - new_len);
			    }
			}
		    }
		}
	      else if (form == DW_FORM_strp)
		edit_attributes_str_comp_dir (false /* line_strp */, dso,
					      &ptr, phase, &comp_dir,
					      &handled_strp);
	      else if (form == DW_FORM_line_strp)
		edit_attributes_str_comp_dir (true /* line_strp */, dso, &ptr,
					      phase, &comp_dir, &handled_strp);
	    }
	  else if ((t->tag == DW_TAG_compile_unit
		    || t->tag == DW_TAG_partial_unit)
		   && ((form == DW_FORM_strp
			&& debug_sections[DEBUG_STR].data)
		       || (form == DW_FORM_line_strp
			   && debug_sections[DEBUG_LINE_STR].data))
		   && t->attr[i].attr == DW_AT_name)
	    {
	      bool line_strp = form == DW_FORM_line_strp;

	      /* DW_AT_name is the primary file for this compile
		 unit. If starting with / it is a full path name.
		 Note that we don't handle DW_FORM_string in this
		 case.  */
	      size_t idx = do_read_32_relocated (ptr);

	      /* In phase zero we will look for a comp_dir to use.  */
	      if (phase == 0)
		{
		  debug_section *sec = &debug_sections[line_strp
						       ? DEBUG_LINE_STR
						       : DEBUG_STR];
		  if (idx >= sec->size)
		    error (1, 0,
			   "%s: Bad string pointer index %zd for unit name (%s)",
			   dso->filename, idx, sec->name);
		  char *name = (char *) sec->data + idx;
		  if (*name == '/' && comp_dir == NULL)
		    {
		      char *enddir = strrchr (name, '/');

		      if (enddir != name)
			{
			  comp_dir = malloc (enddir - name + 1);
			  memcpy (comp_dir, name, enddir - name);
			  comp_dir [enddir - name] = '\0';
			}
		      else
			comp_dir = strdup ("/");
		    }
		}

	      /* First pass (0) records the new name to be
		 added to the debug string pool, the second
		 pass (1) stores it (the new index). */
	      if (dest_dir && phase == 0)
		{
		  if (record_file_string_entry_idx (line_strp, dso, idx))
		    {
		      if (line_strp)
			need_line_strp_update = true;
		      else
			need_strp_update = true;
		    }
		  handled_strp = true;
		}
	    }

	  switch (form)
	    {
	    case DW_FORM_strp:
	      edit_strp (dso, false /* line_strp */, ptr, phase, handled_strp);
	      break;
	    case DW_FORM_line_strp:
	      edit_strp (dso, true /* line_strp */, ptr, phase, handled_strp);
	      break;
	    }

	  switch (skip_form (dso, &form, &ptr))
	    {
	    case FORM_OK:
	      break;
	    case FORM_ERROR:
	      return NULL;
	    case FORM_INDIRECT:
	      continue;
	    }

	  break;
	}
    }

  /* Ensure the CU current directory will exist even if only empty.  Source
     filenames possibly located in its parent directories refer relatively to
     it and the debugger (GDB) cannot safely optimize out the missing
     CU current dir subdirectories.  Only do this once in phase one. And
     only do this for dirs under our build/base_dir.  Don't output the
     empty string (in case the comp_dir == base_dir).  */
  if (phase == 0 && base_dir && comp_dir && list_file_fd != -1)
    {
      const char *p = skip_dir_prefix (comp_dir, base_dir);
      if (p != NULL && p[0] != '\0')
        {
	  size_t size = strlen (p);
	  while (size > 0)
	    {
	      ssize_t ret = write (list_file_fd, p, size);
	      if (ret == -1)
		error (1, errno, "Could not write to '%s'", list_file);
	      size -= ret;
	      p += ret;
	    }
	  /* Output trailing dir separator to distinguish them quickly from
	     regular files. */
	  if (size == 0)
	    {
	      ssize_t ret;
	      if (*(p - 1) != '/')
		ret = write (list_file_fd, "/", 2);
	      else
		ret = write (list_file_fd, "", 1);
	      if (ret == -1)
		error (1, errno, "Could not write to '%s'", list_file);
	    }
	}
    }

  /* In phase zero we collect all file names (we need the comp_dir for
     that).  Note that calculating the new size and offsets is done
     separately (at the end of phase zero after all CUs have been
     scanned in dwarf2_edit). */
  if (phase == 0 && found_list_offs
      && read_dwarf2_line (dso, list_offs, comp_dir))
    need_stmt_update = true;

  free (comp_dir);

  return ptr;
}

static int
line_rel_cmp (const void *a, const void *b)
{
  LINE_REL *rela = (LINE_REL *) a, *relb = (LINE_REL *) b;

  if (rela->r_offset < relb->r_offset)
    return -1;

  if (rela->r_offset > relb->r_offset)
    return 1;

  return 0;
}

static int
edit_info (DSO *dso, int phase, struct debug_section *sec)
{
  unsigned char *ptr, *endcu, *endsec;
  uint32_t value;
  htab_t abbrev;
  struct abbrev_tag tag, *t;

  ptr = sec->data;
  if (ptr == NULL)
    return 0;

  setup_relbuf(dso, sec, &reltype);
  endsec = ptr + sec->size;
  while (ptr < endsec)
    {
      unsigned char *cu_start = ptr;

      /* header size, version, unit_type, ptr_size.  */
      if (ptr + 4 + 2 + 1 + 1 > endsec)
	{
	  error (0, 0, "%s: %s CU header too small",
		 dso->filename, sec->name);
	  return 1;
	}

      endcu = ptr + 4;
      endcu += read_32 (ptr);
      if (endcu == ptr + 0xffffffff)
	{
	  error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
	  return 1;
	}

      if (endcu > endsec)
	{
	  error (0, 0, "%s: %s too small", dso->filename, sec->name);
	  return 1;
	}

      cu_version = read_16 (ptr);
      if (cu_version != 2 && cu_version != 3 && cu_version != 4
	  && cu_version != 5)
	{
	  error (0, 0, "%s: DWARF version %d unhandled", dso->filename,
		 cu_version);
	  return 1;
	}

      int cu_ptr_size = 0;

      if (cu_version >= 5)
	{
	  uint8_t unit_type = read_8 (ptr);
	  if (unit_type != DW_UT_compile && unit_type != DW_UT_partial)
	    {
	      error (0, 0, "%s: Unit type %u unhandled", dso->filename,
		     unit_type);
	      return 1;
	    }

	  cu_ptr_size = read_8 (ptr);
	}

      unsigned char *header_end = (cu_start + 23 + (cu_version < 5 ? 0 : 1));
      if (header_end > endsec)
	{
	  error (0, 0, "%s: %s CU header too small", dso->filename, sec->name);
	  return 1;
	}

      value = read_32_relocated (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);
	  return 1;
	}

      if (cu_version < 5)
	cu_ptr_size = read_8 (ptr);

      if (ptr_size == 0)
	{
	  ptr_size = cu_ptr_size;
	  if (ptr_size != 4 && ptr_size != 8)
	    {
	      error (0, 0, "%s: Invalid DWARF pointer size %d",
		     dso->filename, ptr_size);
	      return 1;
	    }
	}
      else if (cu_ptr_size != ptr_size)
	{
	  error (0, 0, "%s: DWARF pointer size differs between CUs",
		 dso->filename);
	  return 1;
	}

      if (sec != &debug_sections[DEBUG_INFO])
	ptr += 12; /* Skip type_signature and type_offset.  */

      abbrev = read_abbrev (dso,
			    debug_sections[DEBUG_ABBREV].data + value);
      if (abbrev == NULL)
	return 1;

      while (ptr < endcu)
	{
	  tag.entry = read_uleb128 (ptr);
	  if (tag.entry == 0)
	    continue;
	  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);
	      htab_delete (abbrev);
	      return 1;
	    }

	  ptr = edit_attributes (dso, ptr, t, phase);
	  if (ptr == NULL)
	    break;
	}

      htab_delete (abbrev);
    }

  return 0;
}

/* Rebuild .debug_str.  */
static void
edit_dwarf2_any_str (DSO *dso, struct strings *strings, debug_section *secp)
{
  Strtab *strtab = strings->str_tab;
  Elf_Data *strdata = secp->elf_data;
  int strndx = secp->sec;
  Elf_Scn *strscn = dso->scn[strndx];

  /* Out with the old. */
  strdata->d_size = 0;
  /* In with the new. */
  strdata = elf_newdata (strscn);

  /* We really should check whether we had enough memory,
     but the old ebl version will just abort on out of
     memory... */
  strtab_finalize (strtab, strdata);
  secp->size = strdata->d_size;
  strings->str_buf = strdata->d_buf;
}

static int
edit_dwarf2 (DSO *dso)
{
  Elf_Data *data;
  Elf_Scn *scn;
  int i, j;

  for (i = 0; debug_sections[i].name; ++i)
    {
      debug_sections[i].data = NULL;
      debug_sections[i].size = 0;
      debug_sections[i].sec = 0;
      debug_sections[i].relsec = 0;
    }
  ptr_size = 0;

  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)
	  {
	    for (j = 0; debug_sections[j].name; ++j)
	      if (strcmp (name, debug_sections[j].name) == 0)
	 	{
		  struct debug_section *debug_sec = &debug_sections[j];
		  if (debug_sections[j].data)
		    {
		      if (j != DEBUG_MACRO && j != DEBUG_TYPES)
			{
			  error (0, 0, "%s: Found two copies of %s section",
				 dso->filename, name);
			  return 1;
			}
		      else
			{
			  /* In relocatable files .debug_macro and .debug_types
			     might appear multiple times as COMDAT section.  */
			  struct debug_section *sec;
			  sec = calloc (sizeof (struct debug_section), 1);
			  if (sec == NULL)
			    error (1, errno,
				   "%s: Could not allocate more %s sections",
				   dso->filename, name);
			  sec->name = name;

			  struct debug_section *multi_sec = debug_sec;
			  while (multi_sec->next != NULL)
			    multi_sec = multi_sec->next;

			  multi_sec->next = sec;
			  debug_sec = sec;
			}
		    }

		  scn = dso->scn[i];
		  data = elf_getdata (scn, NULL);
		  assert (data != NULL && data->d_buf != NULL);
		  assert (elf_getdata (scn, data) == NULL);
		  assert (data->d_off == 0);
		  assert (data->d_size == dso->shdr[i].sh_size);
		  debug_sec->data = data->d_buf;
		  debug_sec->elf_data = data;
		  debug_sec->size = data->d_size;
		  debug_sec->sec = i;
		  break;
		}

	    if (debug_sections[j].name == NULL)
	      {
		error (0, 0, "%s: Unknown debugging section %s",
		       dso->filename, name);
	      }
	  }
	else if (dso->ehdr.e_type == ET_REL
		 && ((dso->shdr[i].sh_type == SHT_REL
		      && strncmp (name, ".rel.debug_",
				  sizeof (".rel.debug_") - 1) == 0)
		     || (dso->shdr[i].sh_type == SHT_RELA
			 && strncmp (name, ".rela.debug_",
				     sizeof (".rela.debug_") - 1) == 0)))
	  {
	    for (j = 0; debug_sections[j].name; ++j)
	      if (strcmp (name + sizeof (".rel") - 1
			  + (dso->shdr[i].sh_type == SHT_RELA),
			  debug_sections[j].name) == 0)
	 	{
		  if (j == DEBUG_MACRO || j == DEBUG_TYPES)
		    {
		      /* Pick the correct one.  */
		      int rel_target = dso->shdr[i].sh_info;
		      struct debug_section *multi_sec = &debug_sections[j];
		      while (multi_sec != NULL)
			{
			  if (multi_sec->sec == rel_target)
			    {
			      multi_sec->relsec = i;
			      break;
			    }
			  multi_sec = multi_sec->next;
			}
		      if (multi_sec == NULL)
			error (0, 1, "No %s reloc section: %s",
			       debug_sections[j].name, dso->filename);
		    }
		  else
		    debug_sections[j].relsec = i;
		  break;
		}
	  }
      }

  if (dso->ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
    {
      do_read_16 = buf_read_ule16;
      do_read_32 = buf_read_ule32;
      do_write_16 = dwarf2_write_le16;
      do_write_32 = dwarf2_write_le32;
    }
  else if (dso->ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
    {
      do_read_16 = buf_read_ube16;
      do_read_32 = buf_read_ube32;
      do_write_16 = dwarf2_write_be16;
      do_write_32 = dwarf2_write_be32;
    }
  else
    {
      error (0, 0, "%s: Wrong ELF data enconding", dso->filename);
      return 1;
    }

  if (debug_sections[DEBUG_INFO].data == NULL)
    return 0;

  unsigned char *ptr, *endsec;
  int phase;
  bool info_rel_updated = false;
  bool types_rel_updated = false;
  bool macro_rel_updated = false;
  bool line_rel_updated = false;

  for (phase = 0; phase < 2; phase++)
    {
      /* If we don't need to update anyhing, skip phase 1. */
      if (phase == 1
	  && !need_strp_update
	  && !need_line_strp_update
	  && !need_string_replacement
	  && !need_stmt_update)
	break;

      rel_updated = false;
      if (edit_info (dso, phase, &debug_sections[DEBUG_INFO]))
	return 1;

      /* Remember whether any .debug_info relocations might need
	 to be updated. */
      info_rel_updated = rel_updated;

      rel_updated = false;
      struct debug_section *types_sec = &debug_sections[DEBUG_TYPES];
      while (types_sec != NULL)
	{
	  if (edit_info (dso, phase, types_sec))
	    return 1;
	  types_sec = types_sec->next;
	}

      /* Remember whether any .debug_types relocations might need
	 to be updated. */
      types_rel_updated = rel_updated;

      /* We might have to recalculate/rewrite the debug_line
	 section.  We need to do that before going into phase one
	 so we have all new offsets.  We do this separately from
	 scanning the dirs/file names because the DW_AT_stmt_lists
	 might not be in order or skip some padding we might have
	 to (re)move. */
      if (phase == 0 && need_stmt_update)
	{
	  edit_dwarf2_line (dso);

	  /* The line table programs will be moved
	     forward/backwards a bit in the new data. Update the
	     debug_line relocations to the new offsets. */
	  int rndx = debug_sections[DEBUG_LINE].relsec;
	  if (rndx != 0)
	    {
	      LINE_REL *rbuf;
	      size_t rels;
	      Elf_Data *rdata = elf_getdata (dso->scn[rndx], NULL);
	      int rtype = dso->shdr[rndx].sh_type;
	      rels = dso->shdr[rndx].sh_size / dso->shdr[rndx].sh_entsize;
	      rbuf = malloc (rels * sizeof (LINE_REL));
	      if (rbuf == NULL)
		error (1, errno, "%s: Could not allocate line relocations",
		       dso->filename);

	      /* Sort them by offset into section. */
	      for (size_t i = 0; i < rels; i++)
		{
		  if (rtype == SHT_RELA)
		    {
		      GElf_Rela rela;
		      if (gelf_getrela (rdata, i, &rela) == NULL)
			error (1, 0, "Couldn't get relocation: %s",
			       elf_errmsg (-1));
		      rbuf[i].r_offset = rela.r_offset;
		      rbuf[i].ndx = i;
		    }
		  else
		    {
		      GElf_Rel rel;
		      if (gelf_getrel (rdata, i, &rel) == NULL)
			error (1, 0, "Couldn't get relocation: %s",
			       elf_errmsg (-1));
		      rbuf[i].r_offset = rel.r_offset;
		      rbuf[i].ndx = i;
		    }
		}
	      qsort (rbuf, rels, sizeof (LINE_REL), line_rel_cmp);

	      size_t lndx = 0;
	      for (size_t i = 0; i < rels; i++)
		{
		  /* These relocations only happen in ET_REL files
		     and are section offsets. */
		  GElf_Addr r_offset;
		  size_t ndx = rbuf[i].ndx;

		  GElf_Rel rel;
		  GElf_Rela rela;
		  if (rtype == SHT_RELA)
		    {
		      if (gelf_getrela (rdata, ndx, &rela) == NULL)
			error (1, 0, "Couldn't get relocation: %s",
			       elf_errmsg (-1));
		      r_offset = rela.r_offset;
		    }
		  else
		    {
		      if (gelf_getrel (rdata, ndx, &rel) == NULL)
			error (1, 0, "Couldn't get relocation: %s",
			       elf_errmsg (-1));
		      r_offset = rel.r_offset;
		    }

		  while (lndx < dso->lines.used
			 && r_offset > (dso->lines.table[lndx].old_idx
					+ 4
					+ dso->lines.table[lndx].unit_length))
		    lndx++;

		  if (lndx >= dso->lines.used)
		    error (1, 0,
			   ".debug_line relocation offset out of range");

		  /* Offset (pointing into the line program) moves
		     from old to new index including the header
		     size diff. */
		  r_offset += (ssize_t)((dso->lines.table[lndx].new_idx
					 - dso->lines.table[lndx].old_idx)
					+ dso->lines.table[lndx].size_diff);

		  if (rtype == SHT_RELA)
		    {
		      rela.r_offset = r_offset;
		      if (gelf_update_rela (rdata, ndx, &rela) == 0)
			error (1, 0, "Couldn't update relocation: %s",
			       elf_errmsg (-1));
		    }
		  else
		    {
		      rel.r_offset = r_offset;
		      if (gelf_update_rel (rdata, ndx, &rel) == 0)
			error (1, 0, "Couldn't update relocation: %s",
			       elf_errmsg (-1));
		    }
		}

	      elf_flagdata (rdata, ELF_C_SET, ELF_F_DIRTY);
	      free (rbuf);
	    }
	}

      /* The .debug_macro section also contains offsets into the
	 .debug_str section and references to the .debug_line
	 tables, so we need to update those as well if we update
	 the strings or the stmts.  */
      if ((need_strp_update || need_stmt_update)
	  && debug_sections[DEBUG_MACRO].data)
	{
	  /* There might be multiple (COMDAT) .debug_macro sections.  */
	  struct debug_section *macro_sec = &debug_sections[DEBUG_MACRO];
	  while (macro_sec != NULL)
	    {
	      setup_relbuf(dso, macro_sec, &reltype);
	      rel_updated = false;

	      ptr = macro_sec->data;
	      endsec = ptr + macro_sec->size;
	      int op = 0, macro_version, macro_flags;
	      int offset_len = 4, line_offset = 0;

	      while (ptr < endsec)
		{
		  if (!op)
		    {
		      macro_version = read_16 (ptr);
		      macro_flags = read_8 (ptr);
		      if (macro_version < 4 || macro_version > 5)
			error (1, 0, "unhandled .debug_macro version: %d",
			       macro_version);
		      if ((macro_flags & ~2) != 0)
			error (1, 0, "unhandled .debug_macro flags: 0x%x",
			       macro_flags);

		      offset_len = (macro_flags & 0x01) ? 8 : 4;
		      line_offset = (macro_flags & 0x02) ? 1 : 0;

		      if (offset_len != 4)
			error (0, 1,
			       "Cannot handle 8 byte macro offsets: %s",
			       dso->filename);

		      /* Update the line_offset if it is there.  */
		      if (line_offset)
			{
			  if (phase == 0)
			    ptr += offset_len;
			  else
			    {
			      size_t idx, new_idx;
			      idx = do_read_32_relocated (ptr);
			      new_idx = find_new_list_offs (&dso->lines,
							    idx);
			      write_32_relocated (ptr, new_idx);
			    }
			}
		    }

		  op = read_8 (ptr);
		  if (!op)
		    continue;
		  switch(op)
		    {
		    case DW_MACRO_GNU_define:
		    case DW_MACRO_GNU_undef:
		      read_uleb128 (ptr);
		      ptr = ((unsigned char *) strchr ((char *) ptr, '\0')
			     + 1);
		      break;
		    case DW_MACRO_GNU_start_file:
		      read_uleb128 (ptr);
		      read_uleb128 (ptr);
		      break;
		    case DW_MACRO_GNU_end_file:
		      break;
		    case DW_MACRO_GNU_define_indirect:
		    case DW_MACRO_GNU_undef_indirect:
		      read_uleb128 (ptr);
		      if (phase == 0)
			{
			  size_t idx = read_32_relocated (ptr);
			  record_existing_string_entry_idx (false, dso, idx);
			}
		      else
			{
			  struct stridxentry *entry;
			  size_t idx, new_idx;
			  idx = do_read_32_relocated (ptr);
			  entry = string_find_entry (&dso->debug_str, idx);
			  new_idx = strent_offset (entry->entry);
			  write_32_relocated (ptr, new_idx);
			}
		      break;
		    case DW_MACRO_GNU_transparent_include:
		      ptr += offset_len;
		      break;
		    default:
		      error (1, 0, "Unhandled DW_MACRO op 0x%x", op);
		      break;
		    }
		}

	      if (rel_updated)
		macro_rel_updated = true;
	      macro_sec = macro_sec->next;
	    }
	}


      /* Now handle all the DWARF5 line tables, they contain strp
	 and/or line_strp entries that need to be registered/rewritten.  */
      setup_relbuf(dso, &debug_sections[DEBUG_LINE], &reltype);
      rel_updated = false;

      /* edit_dwarf2_line will have set this up, unless there are no
	 moved/resized (DWARF4) lines. In which case we can just use
	 the original section data. new_idx will have been setup
	 correctly, even if it is the same as old_idx.  */
      unsigned char *line_buf = (unsigned char *)dso->lines.line_buf;
      if (line_buf == NULL)
	line_buf = debug_sections[DEBUG_LINE].data;
      for (int ldx = 0; ldx < dso->lines.used; ldx++)
	{
	  struct line_table *t = &dso->lines.table[ldx];
	  if (t->version >= 5)
	    read_dwarf5_line (dso, line_buf + t->new_idx, t, phase);
	}
      if (rel_updated)
	line_rel_updated = true;

      /* Same for the debug_str and debug_line_str sections.
	 Make sure everything is in place for phase 1 updating of debug_info
	 references. */
      if (phase == 0 && need_strp_update)
	edit_dwarf2_any_str (dso, &dso->debug_str,
			     &debug_sections[DEBUG_STR]);
      if (phase == 0 && need_line_strp_update)
	edit_dwarf2_any_str (dso, &dso->debug_line_str,
			     &debug_sections[DEBUG_LINE_STR]);
    }

  /* After phase 1 we might have rewritten the debug_info with
     new strp, strings and/or linep offsets.  */
  if (need_strp_update || need_line_strp_update
      || need_string_replacement || need_stmt_update) {
    dirty_section (DEBUG_INFO);
    if (debug_sections[DEBUG_TYPES].data != NULL)
      dirty_section (DEBUG_TYPES);
  }
  if (need_strp_update || need_stmt_update)
    dirty_section (DEBUG_MACRO);
  if (need_stmt_update || need_line_strp_update)
    dirty_section (DEBUG_LINE);

  /* Update any relocations addends we might have touched. */
  if (info_rel_updated)
    update_rela_data (dso, &debug_sections[DEBUG_INFO]);
  if (types_rel_updated)
    {
      struct debug_section *types_sec = &debug_sections[DEBUG_TYPES];
      while (types_sec != NULL)
	{
	  update_rela_data (dso, types_sec);
	  types_sec = types_sec->next;
	}
    }

  if (macro_rel_updated)
    {
      struct debug_section *macro_sec = &debug_sections[DEBUG_MACRO];
      while (macro_sec != NULL)
	{
	  update_rela_data (dso, macro_sec);
	  macro_sec = macro_sec->next;
	}
    }

  if (line_rel_updated)
    update_rela_data (dso, &debug_sections[DEBUG_LINE]);

  return 0;
}

static struct option optionsTable[] =
  {
    { "base-dir", required_argument, 0, 'b' },
    { "dest-dir", required_argument, 0, 'd' },
    { "list-file", required_argument, 0, 'l' },
    { "build-id", no_argument, 0, 'i' },
    { "build-id-seed", required_argument, 0, 's' },
    { "no-recompute-build-id", no_argument, 0, 'n' },
    { "version", no_argument, 0, 'V' },
    { "help", no_argument, 0, '?' },
    { "usage", no_argument, 0, 'u' },
    { NULL, 0, 0, 0 }
  };

static const char *optionsChars = "b:d:l:is:nV?";

static const char *helpText =
  "Usage: %s [OPTION...] FILE\n"
  "  -b, --base-dir=STRING           base build directory of objects\n"
  "  -d, --dest-dir=STRING           directory to rewrite base-dir into\n"
  "  -l, --list-file=STRING          file where to put list of source and \n"
  "                                  header file names\n"
  "  -i, --build-id                  recompute build ID note and print ID on\n"
  "                                  stdout\n"
  "  -s, --build-id-seed=STRING      if recomputing the build ID note use\n"
  "                                  this string as hash seed\n"
  "  -n, --no-recompute-build-id     do not recompute build ID note even\n"
  "                                  when-i or -s are given\n"
  "\n"
  "Help options:\n"
  "  -?, --help                      Show this help message\n"
  "  -u, --usage                     Display brief usage message\n"
  "  -V, --version                   Show debugedit version\n";

static const char *usageText =
  "Usage: %s [-in?] [-b|--base-dir STRING] [-d|--dest-dir STRING]\n"
  "        [-l|--list-file STRING] [-i|--build-id] \n"
  "        [-s|--build-id-seed STRING]\n"
  "        [-n|--no-recompute-build-id] [-?|--help] [-u|--usage]\n"
  "        [-V|--version] FILE\n";

static void
help (const char *progname, bool error)
{
  FILE *f = error ? stderr : stdout;
  fprintf (f, helpText, progname);
  exit (error ? EXIT_FAILURE : EXIT_SUCCESS);
}

static void
usage (const char *progname, bool error)
{
  FILE *f = error ? stderr : stdout;
  fprintf (f, usageText, progname);
  exit (error ? EXIT_FAILURE : EXIT_SUCCESS);
}

static DSO *
fdopen_dso (int fd, const char *name)
{
  Elf *elf = NULL;
  GElf_Ehdr ehdr;
  int i;
  DSO *dso = NULL;
  size_t phnum;

  elf = elf_begin (fd, ELF_C_RDWR, 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 && ehdr.e_type != ET_REL)
    {
      error (0, 0, "\"%s\" is not a shared library", name);
      goto error_out;
    }

  /* Allocate DSO structure. Leave place for additional 20 new section
     headers.  */
  dso = (DSO *)
	malloc (sizeof(DSO) + (ehdr.e_shnum + 20) * sizeof(GElf_Shdr)
	        + (ehdr.e_shnum + 20) * sizeof(Elf_Scn *));
  if (!dso)
    {
      error (0, ENOMEM, "Could not open DSO");
      goto error_out;
    }

  if (elf_getphdrnum (elf, &phnum) != 0)
    {
      error (0, 0, "Couldn't get number of phdrs: %s", elf_errmsg (-1));
      goto error_out;
    }

  /* If there are phdrs we want to maintain the layout of the
     allocated sections in the file.  */
  if (phnum != 0)
    elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT);

  memset (dso, 0, sizeof(DSO));
  dso->elf = elf;
  dso->phnum = phnum;
  dso->ehdr = ehdr;
  dso->scn = (Elf_Scn **) &dso->shdr[ehdr.e_shnum + 20];

  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 *) strdup (name);
  setup_strings (&dso->debug_str);
  setup_strings (&dso->debug_line_str);
  setup_lines (&dso->lines);
  return dso;

error_out:
  if (dso)
    {
      free ((char *) dso->filename);
      destroy_strings (&dso->debug_str);
      destroy_strings (&dso->debug_line_str);
      destroy_lines (&dso->lines);
      free (dso);
    }
  if (elf)
    elf_end (elf);
  if (fd != -1)
    close (fd);
  return NULL;
}

/* Compute a fresh build ID bit-string from the editted file contents.  */
static void
handle_build_id (DSO *dso, Elf_Data *build_id,
		 size_t build_id_offset, size_t build_id_size)
{
  /* For now we only handle 16 byte (128 bits) with md5 or 20 bytes
     (160 bits) with sha1.  */

  if (build_id_size != 16 && build_id_size != 20)
    {
      error (1, 0, "Cannot handle %Zu-byte build ID", build_id_size);
    }

  int i = -1;
  if (no_recompute_build_id
      || (! dirty_elf && build_id_seed == NULL))
    goto print;

  /* Clear the old bits so they do not affect the new hash.  */
  memset ((char *) build_id->d_buf + build_id_offset, 0, build_id_size);

  struct md5_ctx md5_ctx;
  struct sha1_ctx sha1_ctx;

  if (build_id_size == 16)
    md5_init_ctx (&md5_ctx);
  else
    sha1_init_ctx (&sha1_ctx);

  /* If a seed string was given use it to prime the hash.  */
  if (build_id_seed != NULL)
    {
      if (build_id_size == 16)
	md5_process_bytes (build_id_seed, strlen (build_id_seed), &md5_ctx);
      else
	sha1_process_bytes (build_id_seed, strlen (build_id_seed), &sha1_ctx);
    }

  /* Slurp the relevant header bits and section contents and feed them
     into the hash function.  The only bits we ignore are the offset
     fields in ehdr and shdrs, since the semantically identical ELF file
     could be written differently if it doesn't change the phdr layout.
     We always use the GElf (i.e. Elf64) formats for the bits to hash
     since it is convenient.  It doesn't matter whether this is an Elf32
     or Elf64 object, only that we are consistent in what bits feed the
     hash so it comes out the same for the same file contents.  */
  {
    union
    {
      GElf_Ehdr ehdr;
      GElf_Phdr phdr;
      GElf_Shdr shdr;
    } u;
    Elf_Data x = { .d_version = EV_CURRENT, .d_buf = &u };

    x.d_type = ELF_T_EHDR;
    x.d_size = sizeof u.ehdr;
    u.ehdr = dso->ehdr;
    u.ehdr.e_phoff = u.ehdr.e_shoff = 0;
    if (elf64_xlatetom (&x, &x, dso->ehdr.e_ident[EI_DATA]) == NULL)
      {
      bad:
	error (1, 0, "Failed to compute header checksum: %s",
	       elf_errmsg (elf_errno ()));
      }

    x.d_type = ELF_T_PHDR;
    x.d_size = sizeof u.phdr;
    for (i = 0; i < dso->ehdr.e_phnum; ++i)
      {
	if (gelf_getphdr (dso->elf, i, &u.phdr) == NULL)
	  goto bad;
	if (elf64_xlatetom (&x, &x, dso->ehdr.e_ident[EI_DATA]) == NULL)
	  goto bad;

	if (build_id_size == 16)
	  md5_process_bytes (x.d_buf, x.d_size, &md5_ctx);
	else
	  sha1_process_bytes (x.d_buf, x.d_size, &sha1_ctx);
      }

    x.d_type = ELF_T_SHDR;
    x.d_size = sizeof u.shdr;
    for (i = 0; i < dso->ehdr.e_shnum; ++i)
      if (dso->scn[i] != NULL)
	{
	  u.shdr = dso->shdr[i];
	  u.shdr.sh_offset = 0;
	  if (elf64_xlatetom (&x, &x, dso->ehdr.e_ident[EI_DATA]) == NULL)
	    goto bad;

	  if (build_id_size == 16)
	    md5_process_bytes (x.d_buf, x.d_size, &md5_ctx);
	  else
	    sha1_process_bytes (x.d_buf, x.d_size, &sha1_ctx);

	  if (u.shdr.sh_type != SHT_NOBITS)
	    {
	      Elf_Data *d = elf_getdata (dso->scn[i], NULL);
	      if (d == NULL)
		goto bad;

	      if (build_id_size == 16)
		md5_process_bytes (d->d_buf, d->d_size, &md5_ctx);
	      else
		sha1_process_bytes (d->d_buf, d->d_size, &sha1_ctx);
	    }
	}
  }

  /* Allocate the memory first to make sure alignment is correct. */
  void *digest = malloc (build_id_size);
  if (digest == NULL)
    goto bad;

  if (build_id_size == 16)
    md5_finish_ctx (&md5_ctx, digest);
  else
    sha1_finish_ctx (&sha1_ctx, digest);

  memcpy((unsigned char *)build_id->d_buf + build_id_offset, digest, build_id_size);
  free(digest);

  elf_flagdata (build_id, ELF_C_SET, ELF_F_DIRTY);

 print:
  /* Now format the build ID bits in hex to print out.  */
  {
    const uint8_t * id = (uint8_t *)build_id->d_buf + build_id_offset;
    size_t blen = build_id_size;
    static char const hex[] = "0123456789abcdef";
    while (blen-- > 0)
      {
	size_t i = *id++;
	printf ("%c%c", hex[(i >> 4) & 0xf], hex[(i) & 0xf]);
      }
    printf ("\n");
  }
}

int
main (int argc, char *argv[])
{
  DSO *dso;
  int fd, i;
  const char *file;
  struct stat stat_buf;
  Elf_Data *build_id = NULL;
  size_t build_id_offset = 0, build_id_size = 0;

  while (1)
    {
      int opt_ndx = -1;
      int c = getopt_long (argc, argv, optionsChars, optionsTable, &opt_ndx);

      if (c == -1)
	break;

      switch (c)
	{
	default:
	case '?':
	  help (argv[0], opt_ndx == -1);
	  break;

	case 'u':
	  usage (argv[0], false);
	  break;

	case 'b':
	  base_dir = optarg;
	  break;

	case 'd':
	  dest_dir = optarg;
	  break;

	case 'l':
	  list_file = optarg;
	  break;

	case 'i':
	  do_build_id = 1;
	  break;

	case 's':
	  build_id_seed = optarg;
	  break;

	case 'n':
	  no_recompute_build_id = 1;
	  break;

	case 'V':
	  show_version = 1;
	  break;
	}
    }

  if (show_version)
    {
      printf("debugedit %s\n", VERSION);
      exit(EXIT_SUCCESS);
    }

  if (optind != argc - 1)
    {
      error (0, 0, "Need one FILE as input");
      usage (argv[0], true);
    }

  if (dest_dir != NULL)
    {
      if (base_dir == NULL)
	{
	  error (1, 0, "You must specify a base dir if you specify a dest dir");
	}
    }

  if (build_id_seed != NULL && do_build_id == 0)
    {
      error (1, 0, "--build-id-seed (-s) needs --build-id (-i)");
    }

  if (build_id_seed != NULL && strlen (build_id_seed) < 1)
    {
      error (1, 0, "--build-id-seed (-s) string should be at least 1 char");
    }

  /* Ensure clean paths, users can muck with these. Also removes any
     trailing '/' from the paths. */
  if (base_dir)
    canonicalize_path(base_dir, base_dir);
  if (dest_dir)
    canonicalize_path(dest_dir, dest_dir);

  if (list_file != NULL)
    {
      list_file_fd = open (list_file, O_WRONLY|O_CREAT|O_APPEND, 0644);
    }

  file = argv[optind];

  if (elf_version(EV_CURRENT) == EV_NONE)
    {
      error (1, 0, "library out of date");
    }

  if (stat(file, &stat_buf) < 0)
    {
      error (1, errno, "Failed to open input file '%s'", file);
    }

  /* Make sure we can read and write */
  if (chmod (file, stat_buf.st_mode | S_IRUSR | S_IWUSR) != 0)
    error (0, errno, "Failed to chmod input file '%s' to make sure we can read and write", file);

  fd = open (file, O_RDWR);
  if (fd < 0)
    {
      error (1, errno, "Failed to open input file '%s'", file);
    }

  dso = fdopen_dso (fd, file);
  if (dso == NULL)
    exit (1);

  for (i = 1; i < dso->ehdr.e_shnum; i++)
    {
      const char *name;

      switch (dso->shdr[i].sh_type)
	{
	case SHT_MIPS_DWARF:
	  /* According to the specification, all MIPS .debug_* sections are
	     marked with ELF type SHT_MIPS_DWARF. As SHT_MIPS_DWARF is from
	     processor-specific range, we have to check that we're actually
	     dealing with MIPS ELF file before handling such sections.  */
	  if (dso->ehdr.e_machine != EM_MIPS
	      && dso->ehdr.e_machine != EM_MIPS_RS3_LE) {
	    break;
	  }
	  /*@fallthrough@*/
	case SHT_PROGBITS:
	  name = strptr (dso, dso->ehdr.e_shstrndx, dso->shdr[i].sh_name);
	  /* TODO: Handle stabs */
	  if (strcmp (name, ".stab") == 0)
	    {
	      error (0, 0, "Stabs debuginfo not supported: %s", file);
	      break;
	    }
	  if (!(do_build_id && no_recompute_build_id && !base_dir && !dest_dir)
	      && strcmp (name, ".debug_info") == 0)
	    edit_dwarf2 (dso);

	  break;
	case SHT_NOTE:
	  if (do_build_id
	      && build_id == 0 && (dso->shdr[i].sh_flags & SHF_ALLOC))
	    {
	      /* Look for a build-ID note here.  */
	      size_t off = 0;
	      GElf_Nhdr nhdr;
	      size_t name_off;
	      size_t desc_off;
	      Elf_Data *data = elf_getdata (elf_getscn (dso->elf, i), NULL);
	      while ((off = gelf_getnote (data, off,
					  &nhdr, &name_off, &desc_off)) > 0)
		if (nhdr.n_type == NT_GNU_BUILD_ID
		    && nhdr.n_namesz == sizeof "GNU"
		    && (memcmp ((char *)data->d_buf + name_off, "GNU",
				sizeof "GNU") == 0))
		  {
		    build_id = data;
		    build_id_offset = desc_off;
		    build_id_size = nhdr.n_descsz;
		  }
	    }
	  break;
	default:
	  break;
	}
    }

  /* Normally we only need to explicitly update the section headers
     and data when any section data changed size. But because of a bug
     in elfutils before 0.169 we will have to update and write out all
     section data if any data has changed (when ELF_F_LAYOUT was
     set). https://sourceware.org/bugzilla/show_bug.cgi?id=21199 */
  bool need_update = (need_strp_update
		      || need_line_strp_update
		      || need_stmt_update);

#if !_ELFUTILS_PREREQ (0, 169)
  /* string replacements or build_id updates don't change section size. */
  need_update = (need_update
		 || need_string_replacement
		 || (do_build_id && build_id != NULL));
#endif

  /* We might have changed the size of some debug sections. If so make
     sure the section headers are updated and the data offsets are
     correct. We set ELF_F_LAYOUT above because we don't want libelf
     to move any allocated sections around itself if there are any
     phdrs. Which means we are responsible for setting the section size
     and offset fields. Plus the shdr offsets. We don't want to change
     anything for the phdrs allocated sections. Keep the offset of
     allocated sections so they are at the same place in the file. Add
     unallocated ones after the allocated ones. */
  if (dso->phnum != 0 && need_update)
    {
      Elf *elf = dso->elf;
      GElf_Off last_offset;
      /* We position everything after the phdrs (which normally would
	 be at the start of the ELF file after the ELF header. */
      last_offset = (dso->ehdr.e_phoff + gelf_fsize (elf, ELF_T_PHDR,
						     dso->phnum, EV_CURRENT));

      /* First find the last allocated section.  */
      Elf_Scn *scn = NULL;
      while ((scn = elf_nextscn (elf, scn)) != NULL)
	{
	  GElf_Shdr shdr_mem;
	  GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
	  if (shdr == NULL)
	    error (1, 0, "Couldn't get shdr: %s", elf_errmsg (-1));

	  /* Any sections we have changed aren't allocated sections,
	     so we don't need to lookup any changed section sizes. */
	  if ((shdr->sh_flags & SHF_ALLOC) != 0)
	    {
	      GElf_Off off = shdr->sh_offset + (shdr->sh_type != SHT_NOBITS
						? shdr->sh_size : 0);
	      if (last_offset < off)
		last_offset = off;
	    }
	}

      /* Now adjust any sizes and offsets for the unallocated sections. */
      scn = NULL;
      while ((scn = elf_nextscn (elf, scn)) != NULL)
	{
	  GElf_Shdr shdr_mem;
	  GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
	  if (shdr == NULL)
	    error (1, 0, "Couldn't get shdr: %s", elf_errmsg (-1));

	  /* A bug in elfutils before 0.169 means we have to write out
	     all section data, even when nothing changed.
	     https://sourceware.org/bugzilla/show_bug.cgi?id=21199 */
#if !_ELFUTILS_PREREQ (0, 169)
	  if (shdr->sh_type != SHT_NOBITS)
	    {
	      Elf_Data *d = elf_getdata (scn, NULL);
	      elf_flagdata (d, ELF_C_SET, ELF_F_DIRTY);
	    }
#endif
	  if ((shdr->sh_flags & SHF_ALLOC) == 0)
	    {
	      GElf_Off sec_offset = shdr->sh_offset;
	      GElf_Xword sec_size = shdr->sh_size;

	      /* We might have changed the size (and content) of the
		 debug_str, debug_line_str or debug_line section. */
	      size_t secnum = elf_ndxscn (scn);
	      if (secnum == debug_sections[DEBUG_STR].sec)
		sec_size = debug_sections[DEBUG_STR].size;
	      if (secnum == debug_sections[DEBUG_LINE_STR].sec)
		sec_size = debug_sections[DEBUG_LINE_STR].size;
	      if (secnum == debug_sections[DEBUG_LINE].sec)
		sec_size = debug_sections[DEBUG_LINE].size;

	      /* Zero means one.  No alignment constraints.  */
	      size_t addralign = shdr->sh_addralign ?: 1;
	      last_offset = (last_offset + addralign - 1) & ~(addralign - 1);
	      sec_offset = last_offset;
	      if (shdr->sh_type != SHT_NOBITS)
		last_offset += sec_size;

	      if (shdr->sh_size != sec_size
		  || shdr->sh_offset != sec_offset)
		{
		  /* Make sure unchanged section data is written out
		     at the new location. */
		  if (shdr->sh_offset != sec_offset
		      && shdr->sh_type != SHT_NOBITS)
		    {
		      Elf_Data *d = elf_getdata (scn, NULL);
		      elf_flagdata (d, ELF_C_SET, ELF_F_DIRTY);
		    }

		  shdr->sh_size = sec_size;
		  shdr->sh_offset = sec_offset;
		  if (gelf_update_shdr (scn, shdr) == 0)
		    error (1, 0, "Couldn't update shdr: %s",
			   elf_errmsg (-1));
		}
	    }
	}

      /* Position the shdrs after the last (unallocated) section.  */
      const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT);
      GElf_Off new_offset = ((last_offset + offsize - 1)
			     & ~((GElf_Off) (offsize - 1)));
      if (dso->ehdr.e_shoff != new_offset)
	{
	  dso->ehdr.e_shoff = new_offset;
	  if (gelf_update_ehdr (elf, &dso->ehdr) == 0)
	    error (1, 0, "Couldn't update ehdr: %s", elf_errmsg (-1));
	}
    }

  if (elf_update (dso->elf, ELF_C_NULL) < 0)
    {
      error (1, 0, "Failed to update file: %s", elf_errmsg (elf_errno ()));
    }

  if (do_build_id && build_id != NULL)
    handle_build_id (dso, build_id, build_id_offset, build_id_size);

  if (elf_update (dso->elf, ELF_C_WRITE) < 0)
    {
      error (1, 0, "Failed to write file: %s", elf_errmsg (elf_errno()));
    }
  if (elf_end (dso->elf) < 0)
    {
      error (1, 0, "elf_end failed: %s", elf_errmsg (elf_errno()));
    }
  close (fd);

  /* Restore old access rights */
  if (chmod (file, stat_buf.st_mode) != 0)
    error (0, errno, "Failed to chmod input file '%s' to restore old access rights", file);

  free ((char *) dso->filename);
  destroy_strings (&dso->debug_str);
  destroy_strings (&dso->debug_line_str);
  destroy_lines (&dso->lines);
  free (dso);

  /* In case there were multiple (COMDAT) .debug_macro sections,
     free them.  */
  struct debug_section *macro_sec = &debug_sections[DEBUG_MACRO];
  macro_sec = macro_sec->next;
  while (macro_sec != NULL)
    {
      struct debug_section *next = macro_sec->next;
      free (macro_sec);
      macro_sec = next;
    }

  /* In case there were multiple (COMDAT) .debug_types sections,
     free them.  */
  struct debug_section *types_sec = &debug_sections[DEBUG_TYPES];
  types_sec = types_sec->next;
  while (types_sec != NULL)
    {
      struct debug_section *next = types_sec->next;
      free (types_sec);
      types_sec = next;
    }

  return 0;
}
