From 481a17c207809d10efcc87c1f831c5eef83c069f Mon Sep 17 00:00:00 2001

Message-Id: <481a17c207809d10efcc87c1f831c5eef83c069f.1488964568.git.pmatilai@redhat.com>

In-Reply-To: <189b4f88c8e100155ec23a1e0b214bdc8473532a.1488964568.git.pmatilai@redhat.com>

References: <189b4f88c8e100155ec23a1e0b214bdc8473532a.1488964568.git.pmatilai@redhat.com>

From: Mark Wielaard <mark@klomp.org>

Date: Fri, 17 Feb 2017 14:13:57 +0100

Subject: [PATCH 10/11] debugedit: Support String/Line table rewriting for

 larger/smaller paths.

debugedit --base to --dest rewriting of debug source file paths only

supported dest paths that were smaller or equal than the base path

(and the size should differ more than 1 character for correct debug lines).

All paths were changed "in place". Which could in theory mess up debug str

sharing.

This rewrite supports base and dest strings of any size (some limitations,

see below). This is done by reconstructing the debug_str and debug_line

tables and updating the references in the debug_info attributes pointing

to these tables. Plus, if necessary (only for ET_REL kernel modules),

updating any relocations for the debug_info and debug_line sections.

This has the nice benefit of merging any duplicate strings in the

debug_str table which might resulting on slightly smaller files.

kernel modules are ET_REL files that often contain a lot of duplicate

strings.

The rewrite uses elfutils (either libebl or libdw) to reconstruct the

debug_str table. Since we are changing some section sizes now we cannot

just use mmap and rawdata to poke the values, but need to read in and

write out the changed sections. This does take a bit more memory because

we now also need to keep track of all string/line references.

There are still some limitations (already in the original debugedit)

not fixed by this rewrite:

- DW_AT_comp_dir in .debug_info using DW_FORM_string can not be made

  larger. We only warn about that now instead of failing. The only

  producer of DW_FORM_string comp_dirs is binutils gas. It seems simpler

  to fix gas than to try to support resizing the debug_info section.

- A DW_AT_name on a DW_TAG_compile_unit is only rewritten for DW_FORM_strp

  not for DW_FORM_string. Probably no problem in practice since this

  wasn't supported originally either.

- The debug_line program isn't scanned for DW_LNE_define_file which

  could in theory define an absolute path that might need rewriting.

  Again probably not a problem because this wasn't supported before

  and there are no know producers for this construct.

To support the upcoming DWARFv5 in gcc 7 (not on by default), we will

need to add support for the new debug_line format and scan the new

debug_macro section that can have references to the debug_str table.

Signed-off-by: Mark Wielaard <mark@klomp.org>

---

 Makefile.am       |    8 +-

 configure.ac      |    6 +

 tools/debugedit.c | 1569 ++++++++++++++++++++++++++++++++++++++++++++---------

 3 files changed, 1330 insertions(+), 253 deletions(-)

diff --git a/Makefile.am b/Makefile.am

index 6b37b58..1b77730 100644

--- a/Makefile.am

+++ b/Makefile.am

@@ -156,13 +156,18 @@ rpm2archive_LDADD +=	@WITH_NSS_LIB@ @WITH_POPT_LIB@ @WITH_ZLIB_LIB@ @WITH_ARCHIV

 if LIBELF

 if LIBDWARF

+if LIBDW

 rpmconfig_SCRIPTS += scripts/find-debuginfo.sh

 rpmlibexec_PROGRAMS +=	debugedit

 debugedit_SOURCES =	tools/debugedit.c tools/hashtab.c tools/hashtab.h

 debugedit_LDADD =	rpmio/librpmio.la

 debugedit_LDADD +=	@WITH_LIBELF_LIB@ @WITH_POPT_LIB@

-

+if HAVE_LIBDW_STRTAB

+debugedit_LDADD +=	@WITH_LIBDW_LIB@

+else

+debugedit_LDADD +=	@WITH_LIBDW_LIB@ -lebl

+endif

 rpmlibexec_PROGRAMS +=	elfdeps

 elfdeps_SOURCES =	tools/elfdeps.c

 elfdeps_LDADD =		rpmio/librpmio.la

@@ -173,6 +178,7 @@ sepdebugcrcfix_SOURCES = tools/sepdebugcrcfix.c

 sepdebugcrcfix_LDADD =	@WITH_LIBELF_LIB@

 endif

 endif

+endif

 rpmlibexec_PROGRAMS +=	rpmdeps

 rpmdeps_SOURCES =	tools/rpmdeps.c

diff --git a/configure.ac b/configure.ac

index 4baa3f1..743fe08 100644

--- a/configure.ac

+++ b/configure.ac

@@ -369,18 +369,24 @@ AM_CONDITIONAL(WITH_ARCHIVE,[test "$with_archive" = yes])

 #=================

 # Check for elfutils libdw library with dwelf_elf_gnu_build_id.

 WITH_LIBDW_LIB=

+HAVE_LIBDW_STRTAB=

 AS_IF([test "$WITH_LIBELF" = yes],[

   AC_CHECK_HEADERS([elfutils/libdwelf.h],[

+    # dwelf_elf_gnu_build_id was introduced in elfutils 0.159

     AC_CHECK_LIB(dw, dwelf_elf_gnu_build_id, [

       AC_DEFINE(HAVE_LIBDW, 1,

                 [Define to 1 if you have elfutils libdw library])

       WITH_LIBDW_LIB="-ldw"

       WITH_LIBDW=yes

+      # If possible we also want the strtab functions from elfutils 0.167.

+      # But we can fall back on the (unsupported) ebl alternatives if not.

+      AC_CHECK_LIB(dw, dwelf_strtab_init, [HAVE_LIBDW_STRTAB=yes])

     ])

   ])

 ])

 AC_SUBST(WITH_LIBDW_LIB)

 AM_CONDITIONAL(LIBDW,[test "$WITH_LIBDW" = yes])

+AM_CONDITIONAL(HAVE_LIBDW_STRTAB,[test "$HAVE_LIBDW_STRTAB" = yes])

 #=================

 # Process --with/without-external-db

diff --git a/tools/debugedit.c b/tools/debugedit.c

index c0147f0..4798c63 100644

--- a/tools/debugedit.c

+++ b/tools/debugedit.c

@@ -1,6 +1,7 @@

-/* Copyright (C) 2001-2003, 2005, 2007, 2009-2011, 2016 Red Hat, Inc.

+/* 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

@@ -30,6 +31,7 @@

 #include <string.h>

 #include <stdlib.h>

 #include <stdint.h>

+#include <inttypes.h>

 #include <unistd.h>

 #include <sys/types.h>

 #include <sys/stat.h>

@@ -39,6 +41,35 @@

 #include <gelf.h>

 #include <dwarf.h>

+/* 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 <rpm/rpmio.h>

 #include <rpm/rpmpgp.h>

 #include "tools/hashtab.h"

@@ -56,6 +87,99 @@ int list_file_fd = -1;

 int do_build_id = 0;

 char *build_id_seed = NULL;

+/* 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;

+/* 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;

@@ -63,15 +187,42 @@ typedef struct

   Elf_Scn **scn;

   const char *filename;

   int lastscn;

+  size_t phnum;

+  struct strings strings;

+  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;			\

@@ -88,9 +239,23 @@ typedef struct

   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 (*write_32) (unsigned char *ptr, GElf_Addr val);

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

@@ -129,7 +294,7 @@ strptr (DSO *dso, int sec, off_t offset)

   if (offset >= 0 && (GElf_Addr) offset < dso->shdr[sec].sh_size)

     {

       data = NULL;

-      while ((data = elf_rawdata (scn, data)) != NULL)

+      while ((data = elf_getdata (scn, data)) != NULL)

 	{

 	  if (data->d_buf

 	      && offset >= data->d_off

@@ -142,7 +307,7 @@ strptr (DSO *dso, int sec, off_t offset)

 }

-#define read_1(ptr) *ptr++

+#define read_8(ptr) *ptr++

 #define read_16(ptr) ({					\

   uint16_t ret = do_read_16 (ptr);			\

@@ -183,28 +348,73 @@ int reltype;

 })

 static void

-dwarf2_write_le32 (unsigned char *p, GElf_Addr val)

+dwarf2_write_le16 (unsigned char *p, uint16_t v)

 {

-  uint32_t v = (uint32_t) val;

+  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_be32 (unsigned char *p, GElf_Addr val)

+dwarf2_write_be16 (unsigned char *p, uint16_t v)

 {

-  uint32_t v = (uint32_t) val;

+  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.  */

+

+#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;				\

+    }							\

+  else							\

+    do_write_32 (ptr,val);				\

+})

+

+#define write_32_relocated(ptr,val) ({ \

+  do_write_32_relocated (ptr,val);     \

+  ptr += 4;			       \

+})

+

 static struct

   {

     const char *name;

@@ -448,90 +658,638 @@ canonicalize_path (const char *s, char *d)

   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 '/'. */

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

+      while (IS_DIR_SEPARATOR (path[0]))

+	path++;

+      return path;

+    }

+

+  return 0;

+}

+

+/* 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

-has_prefix (const char  *str,

-	    const char  *prefix)

+strent_compare (const void *a, const void *b)

 {

-  size_t str_len;

-  size_t prefix_len;

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

-  str_len = strlen (str);

-  prefix_len = strlen (prefix);

+  if (idx_a < idx_b)

+    return -1;

-  if (str_len < prefix_len)

-    return 0;

+  if (idx_a > idx_b)

+    return 1;

-  return strncmp (str, prefix, prefix_len) == 0;

+  return 0;

 }

-static int dirty_elf;

+/* 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 (struct strings *strings, size_t old_idx)

+{

+  bool ret = false;

+  struct stridxentry *entry = string_find_new_entry (strings, old_idx);

+  if (entry != NULL)

+    {

+      Strent *strent;

+      const char *old_str = (char *)debug_sections[DEBUG_STR].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

-dirty_section (unsigned int sec)

+record_existing_string_entry_idx (struct strings *strings, size_t old_idx)

 {

-  elf_flagdata (debug_sections[sec].elf_data, ELF_C_SET, ELF_F_DIRTY);

-  dirty_elf = 1;

+  struct stridxentry *entry = string_find_new_entry (strings, old_idx);

+  if (entry != NULL)

+    {

+      const char *str = (char *)debug_sections[DEBUG_STR].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 int

-edit_dwarf2_line (DSO *dso, uint32_t off, char *comp_dir, int phase)

+static void

+setup_strings (struct strings *strings)

 {

-  unsigned char *ptr = debug_sections[DEBUG_LINE].data, *dir;

-  unsigned char **dirt;

-  unsigned char *endsec = ptr + debug_sections[DEBUG_LINE].size;

-  unsigned char *endcu, *endprol;

-  unsigned char opcode_base;

-  uint32_t value, dirt_cnt;

-  size_t comp_dir_len = !comp_dir ? 0 : strlen (comp_dir);

-  size_t abs_file_cnt = 0, abs_dir_cnt = 0;

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

+}

-  if (phase != 0)

-    return 0;

+/* Noop for tdestroy. */

+static void free_node (void *p __attribute__((__unused__))) { }

-  /* XXX: RhBug:929365, should we error out instead of ignoring? */

+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->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)

-    return 0;

+    {

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

-  endcu = ptr + 4;

-  endcu += read_32 (ptr);

+  /* 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 1;

+      return false;

     }

   if (endcu > endsec)

     {

       error (0, 0, "%s: .debug_line CU does not fit into section",

 	     dso->filename);

-      return 1;

+      return false;

     }

-  value = read_16 (ptr);

-  if (value != 2 && value != 3 && value != 4)

+  /* version */

+  t->version = read_16 (ptr);

+  if (t->version != 2 && t->version != 3 && t->version != 4)

     {

       error (0, 0, "%s: DWARF version %d unhandled", dso->filename,

-	     value);

-      return 1;

+	     t->version);

+      return false;

     }

-  endprol = ptr + 4;

-  endprol += read_32 (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 1;

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

+}

-  opcode_base = ptr[4 + (value >= 4)];

-  ptr = dir = ptr + 4 + (value >= 4) + opcode_base;

+static int dirty_elf;

+static void

+dirty_section (unsigned int sec)

+{

+  elf_flagdata (debug_sections[sec].elf_data, ELF_C_SET, ELF_F_DIRTY);

+  dirty_elf = 1;

+}

+

+static int

+line_table_cmp (const void *a, const void *b)

+{