summaryrefslogtreecommitdiffstats
path: root/dwz.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dwz.c16872
1 files changed, 16872 insertions, 0 deletions
diff --git a/dwz.c b/dwz.c
new file mode 100644
index 0000000..3bc6038
--- /dev/null
+++ b/dwz.c
@@ -0,0 +1,16872 @@
+/* Copyright (C) 2001-2021 Red Hat, Inc.
+ Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2019-2021 SUSE LLC.
+ Written by Jakub Jelinek <jakub@redhat.com>, 2012.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, write to
+ the Free Software Foundation, 51 Franklin Street - Fifth Floor,
+ Boston, MA 02110-1301, USA. */
+
+#include <assert.h>
+#include <errno.h>
+#include <error.h>
+#include <fcntl.h>
+#include <setjmp.h>
+#include <string.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/times.h>
+#include <sys/wait.h>
+
+#include <obstack.h>
+
+#include <gelf.h>
+#include <xxhash.h>
+
+#include "dwarf2.h"
+#include "hashtab.h"
+#include "sha1.h"
+#include "args.h"
+#include "util.h"
+#include "pool.h"
+
+#ifndef SHF_COMPRESSED
+ /* Glibc elf.h contains SHF_COMPRESSED starting v2.22. Libelf libelf.h has
+ a fallback definition starting v0.166. Define a fallback definition here
+ for the case of both pre-v2.22 glibc and pre-v0.166 libelf. */
+# define SHF_COMPRESSED (1 << 11) /* Section with compressed data. */
+#endif
+
+/* Theory of operation:
+ The DWZ tool can either optimize debug sections of a single
+ executable or shared library at a time, or, when -m option
+ is used, optimize debug sections even in between different
+ executables or shared libraries by constructing a new ET_REL
+ ELF object containing debug sections to which the individual
+ debug sections in the various executables or shared libraries
+ can refer. As debug info can be pretty large, the multifile
+ optimization is done in several phases in order to decrease
+ memory usage of the tool, which can still be quite high.
+
+ The dwz () function optimizes a single file, and at the end,
+ after processing that single file, it frees all allocated memory.
+ Without -m, the dwz () function is called once on each argument.
+
+ When -m has been passed, the dwz () function is first called on
+ each argument, and during it in addition to performing the same
+ optimizations as dwz tool does without -m it also may append
+ data to several temporary files (one for each .debug_* section
+ that is needed for the multifile optimization). During
+ preparation of the additions to the temporary files (write_multifile
+ function), wr_multifile flag is true.
+
+ Next phase (optimize_multifile) is that all these temporary files
+ are mmapped, it is determined what DIEs, strings, .debug_macro
+ sequences etc. might be beneficial to have in the common debug
+ sections and finally a new ET_REL ELF object is written. During
+ this phase the op_multifile flag is true. This is often very
+ memory consuming phase, so extra hacks are used to decrease
+ the memory usage during it.
+
+ Next phase (read_multifile) is where the previously written ET_REL
+ ELF object is parsed again and needed hash tables and other data
+ structures filled in. The rd_multifile flag is set during this
+ phase. The reason why this phase is separate from the previous one,
+ as opposed to just populating the hash tables right away in
+ optimize_multifile, is that the memory consumption during that phase
+ can be very big and keeping malloced data around would mean the address
+ space would be unnecessarily fragmented. read_multifile usually needs
+ to allocate only small fragment of the memory optimize_multifile
+ needs, on the other side that memory needs to be kept around until
+ the end of the last phase.
+
+ During the last phase, the dwz () function is called second
+ time on each argument, with fi_multifile flag set. During this
+ phase duplicates in the common debug sections are referenced
+ from the local debug sections where possible.
+
+ If some executable or shared library has too large debug information
+ (number of DIEs in .debug_info section) that there would be
+ risk of too high memory consumption, that file isn't multifile
+ optimized, instead it is processed by dwz () in a low-memory mode
+ with low_mem flag set. This can decrease memory consumption to
+ half in some very large cases. */
+
+#ifndef NT_GNU_BUILD_ID
+# define NT_GNU_BUILD_ID 3
+#endif
+
+/* xxHash state object. Init in main. */
+static XXH64_state_t *state;
+
+/* Clear xxHash state to zero. */
+#define hash_init_state() XXH64_reset(state, 0)
+
+/* Update hash STATE with VALUE. */
+#define hash_update_state_object(value) XXH64_update(state, &value, sizeof value)
+
+/* Update hash STATE with OBJECT that has a provided SIZE. */
+#define hash_update_state(object, size) XXH64_update(state, object, size)
+
+/* Get digest once we are done with a state. */
+#define hash_digest() XXH64_digest(state)
+
+/* Shorthand for hashing something with an intrinsic size. */
+#define hash(IN,LEN) XXH64(IN, LEN, 0)
+#define iterative_hash(IN,LEN,INIT) XXH64(IN, LEN, INIT)
+#define iterative_hash_object(OB,INIT) iterative_hash (&OB, sizeof (OB), INIT)
+
+/* Print memory amount M (in kb) in both exact and human readable, like so:
+ 1382508 (1.3G). */
+static void
+print_mem (long m)
+{
+ float h = m;
+ int level = 0;
+ const char *unit[] = { "K", "M", "G"};
+ while (h > 1024 && level <= 2)
+ {
+ h = h / 1024;
+ level++;
+ }
+ fprintf (stderr, "%ld (%.1f%s)\n", m, h, unit[level]);
+}
+
+static void
+report_progress (void)
+{
+ static struct tms current;
+ static struct tms prev;
+ static bool first = true;
+ static long ticks_per_second = 0;
+
+ if (!first)
+ prev = current;
+
+ times (&current);
+
+ if (first)
+ {
+ ticks_per_second = sysconf (_SC_CLK_TCK);
+ first = false;
+ return;
+ }
+
+ clock_t user = current.tms_utime - prev.tms_utime;
+ clock_t sys = current.tms_stime - prev.tms_stime;
+ fprintf (stderr, "user: %.2f\n", (float)user / (float)ticks_per_second);
+ fprintf (stderr, "sys : %.2f\n", (float)sys / (float)ticks_per_second);
+
+ if (progress_mem_p)
+ {
+ FILE *s = fopen ("/proc/self/status", "r");
+ char *p;
+ bool print_next = false;
+ for (p = NULL; fscanf (s, "%ms", &p) && p != NULL; free (p))
+ {
+ if (print_next)
+ {
+ long mem = strtol (p, NULL, 10);
+ print_mem (mem);
+ print_next = false;
+ continue;
+ }
+
+ if (!(p[0] == 'V' && p[1] == 'm'))
+ continue;
+
+ if (strcmp (&p[2], "Peak:") == 0)
+ fprintf (stderr, "VM Peak: ");
+ else if (strcmp (&p[2], "Size:") == 0)
+ fprintf (stderr, "VM Current: ");
+ else if (strcmp (&p[2], "HWM:") == 0)
+ fprintf (stderr, "RSS Peak: ");
+ else if (strcmp (&p[2], "RSS:") == 0)
+ fprintf (stderr, "RSS Current: ");
+ else
+ continue;
+
+ print_next = true;
+ }
+ fclose (s);
+ }
+}
+
+#define obstack_chunk_alloc malloc
+#define obstack_chunk_free free
+
+/* Where to longjmp on OOM. */
+static jmp_buf oom_buf;
+
+/* Handle OOM situation. If handling more than one file, we might
+ just fail to handle some large file due to OOM, but could very well
+ handle other smaller files after it. */
+void
+dwz_oom (void)
+{
+ longjmp (oom_buf, 1);
+}
+
+/* General obstack for struct dw_cu, dw_die, also used for temporary
+ vectors. */
+static struct obstack ob;
+/* Short lived obstack, global only to free it on allocation failures. */
+static struct obstack ob2;
+
+/* After read_multifile ob and ob2 are moved over to these variables
+ and restored during final cleanup. */
+static struct obstack alt_ob, alt_ob2;
+
+static bool odr_active_p = false;
+
+/* Struct to gather statistics. */
+struct stats
+{
+ const char *file;
+ unsigned int root_cnt;
+ unsigned int namespace_cnt;
+ unsigned int lower_toplevel;
+ unsigned int die_count;
+ unsigned int lower_toplevel_with_checksum;
+ unsigned int dup_cnt;
+ unsigned int dup_chain_cnt;
+ unsigned int dup_chain_max_length;
+ unsigned int part_cnt;
+ unsigned int pu_ph1_cnt;
+ unsigned int pu_ph2_cnt;
+ unsigned int pu_toplevel_die_cnt;
+};
+static struct stats *stats;
+
+/* Initialize stats struct. */
+static void
+init_stats (const char *file)
+{
+ if (stats == NULL)
+ stats = (struct stats *)malloc (sizeof (*stats));
+ memset (stats, 0, sizeof (*stats));
+ stats->file = file;
+}
+
+/* Print stats struct, parsing statistics. */
+static void
+print_parse_stats (void)
+{
+ if (stats == NULL || stats->file == NULL)
+ return;
+
+ fprintf (stderr, "Parse statistics for %s\n", stats->file);
+
+ fprintf (stderr, "root_count : %10u\n",
+ stats->root_cnt);
+ fprintf (stderr, "namespace_count : %10u\n",
+ stats->namespace_cnt);
+ unsigned int upper_toplevel = stats->root_cnt + stats->namespace_cnt;
+ fprintf (stderr, "upper_toplevel : %10u\n",
+ upper_toplevel);
+ unsigned lower_toplevel
+ = stats->lower_toplevel + stats->lower_toplevel_with_checksum;
+ fprintf (stderr, "lower_toplevel : %10u\n",
+ lower_toplevel);
+ unsigned int toplevel = upper_toplevel + lower_toplevel;
+ fprintf (stderr, "toplevel : %10u\n",
+ toplevel);
+ unsigned non_toplevel = stats->die_count - toplevel;
+ fprintf (stderr, "non_toplevel : %10u\n",
+ non_toplevel);
+ fprintf (stderr, "die_count : %10u\n",
+ stats->die_count);
+}
+
+/* Print stats struct, dups statistics. */
+static void
+print_dups_stats (void)
+{
+ if (stats == NULL || stats->file == NULL)
+ return;
+
+ fprintf (stderr, "Duplicate statistics for %s\n", stats->file);
+
+ fprintf (stderr, "lower_toplevel with checksum : %10u\n",
+ stats->lower_toplevel_with_checksum);
+ fprintf (stderr, "dup_cnt : %10u\n",
+ stats->dup_cnt);
+ fprintf (stderr, "dup_chain_cnt : %10u\n",
+ stats->dup_chain_cnt);
+ fprintf (stderr, "average dup_chain length : %10.2f\n",
+ (double)stats->dup_cnt / (double)stats->dup_chain_cnt);
+ fprintf (stderr, "max dup_chain length : %10u\n",
+ stats->dup_chain_max_length);
+}
+
+static void
+print_part_stats (void)
+{
+ if (stats == NULL || stats->file == NULL)
+ return;
+
+ fprintf (stderr, "Partition statistics for %s\n", stats->file);
+
+ fprintf (stderr, "part_cnt : %10u\n", stats->part_cnt);
+ fprintf (stderr, "pu_ph1_cnt : %10u\n",
+ stats->pu_ph1_cnt);
+ fprintf (stderr, "pu_ph2_cnt : %10u\n",
+ stats->pu_ph2_cnt);
+ fprintf (stderr, "pu_cnt : %10u\n",
+ stats->pu_ph1_cnt + stats->pu_ph2_cnt);
+ fprintf (stderr, "pu_toplevel_die_cnt : %10u\n",
+ stats->pu_toplevel_die_cnt);
+}
+
+typedef struct
+{
+ Elf *elf;
+ GElf_Ehdr ehdr;
+ Elf_Scn **scn;
+ const char *filename;
+ int lastscn;
+ GElf_Shdr shdr[0];
+} DSO;
+
+/* Macro to parse an uleb128 number, return it and
+ update ptr to the end of the uleb128 at the same time. */
+#define read_uleb128(ptr) ({ \
+ uint64_t ret = 0; \
+ uint64_t c; \
+ int shift = 0; \
+ do \
+ { \
+ c = *ptr++; \
+ ret |= (c & 0x7f) << shift; \
+ shift += 7; \
+ } while (c & 0x80); \
+ \
+ if (shift >= 70) \
+ ret = ~(uint64_t) 0; \
+ ret; \
+})
+
+/* Macro to parse a sleb128 number, return it and
+ update ptr to the end of the sleb128 at the same time. */
+#define read_sleb128(ptr) ({ \
+ uint64_t ret = 0; \
+ uint64_t c; \
+ int shift = 0; \
+ do \
+ { \
+ c = *ptr++; \
+ ret |= (c & 0x7f) << shift; \
+ shift += 7; \
+ } while (c & 0x80); \
+ \
+ if (shift >= 70) \
+ ret = ~(uint64_t) 0; \
+ else if (c & 0x40) \
+ ret |= (-(uint64_t) 1) << shift; \
+ ret; \
+})
+
+/* Macro to store an uleb128 number to ptr and update
+ ptr to point after it. */
+#define write_uleb128(ptr, val) \
+ do \
+ { \
+ uint64_t valv = (val); \
+ do \
+ { \
+ unsigned char c = valv & 0x7f;\
+ valv >>= 7; \
+ if (valv) \
+ c |= 0x80; \
+ *ptr++ = c; \
+ } \
+ while (valv); \
+ } \
+ while (0)
+
+#define write_sleb128(ptr, val) \
+ do \
+ { \
+ int64_t valv = (val); \
+ bool more; \
+ do \
+ { \
+ unsigned char c = valv & 0x7f; \
+ valv >>= 7; \
+ more = ((valv != 0 || (c & 0x40) != 0) \
+ && (valv != -1 || (c & 0x40) == 0)); \
+ if (more) \
+ c |= 0x80; \
+ *ptr++ = c; \
+ } \
+ while (more); \
+ } \
+ while (0)
+
+/* Macro to skip a uleb128 or sleb128 number and update ptr to the end of the
+ number. */
+#define skip_leb128(ptr) \
+ do {} while ((*ptr++) & 0x80)
+
+/* Macro to parse a uint16_t value represented using form, return it and
+ update ptr to the end of the value at the same time. If the value doesn't
+ fit, assign true to error_p. */
+#define read_u16(ptr, form, error_p) \
+ ({ \
+ uint16_t ret = 0; \
+ switch (form) \
+ { \
+ case DW_FORM_data1: \
+ ret = read_8 (ptr); \
+ break; \
+ case DW_FORM_data2: \
+ ret = read_16 (ptr); \
+ break; \
+ case DW_FORM_data4: \
+ { \
+ uint32_t res = read_32 (ptr); \
+ ret = (uint16_t)res; \
+ if ((uint32_t)ret != res) \
+ error_p = true; \
+ break; \
+ } \
+ case DW_FORM_data8: \
+ { \
+ uint64_t res = read_64 (ptr); \
+ ret = (uint16_t)res; \
+ if ((uint64_t)ret != res) \
+ error_p = true; \
+ break; \
+ } \
+ case DW_FORM_udata: \
+ { \
+ uint64_t res = read_uleb128 (ptr); \
+ ret = (uint16_t)res; \
+ if ((uint64_t)ret != res) \
+ error_p = true; \
+ break; \
+ } \
+ case DW_FORM_sdata: \
+ { \
+ union { \
+ uint64_t u; \
+ int64_t i; \
+ } res; \
+ res.u = read_sleb128 (ptr); \
+ ret = (uint16_t)res.u; \
+ if (res.i < 0 || (uint64_t)ret != res.u) \
+ error_p = true; \
+ break; \
+ } \
+ default: \
+ error_p = true; \
+ break; \
+ } \
+ ret; \
+ })
+
+/* Pointer size in the debug info, in bytes. Only debug info
+ with a single pointer size are handled. */
+static int ptr_size;
+
+/* Lowest debug_line version we have seen. When writing out the multi
+ file .debug_line we'll only use a DWARF5 version when there is no
+ lower line table seen (since the debug_line dir and file table is
+ shared between all CUs). */
+static unsigned int lowest_line_version = 5;
+
+/* Utility functions and macros for reading/writing values in
+ given ELF endianity, which might be different from host endianity.
+ No specific alignment is expected. */
+static uint16_t (*do_read_16) (unsigned char *ptr);
+static uint32_t (*do_read_32) (unsigned char *ptr);
+static uint64_t (*do_read_64) (unsigned char *ptr);
+static void (*do_write_16) (unsigned char *ptr, unsigned short val);
+static void (*do_write_32) (unsigned char *ptr, unsigned int val);
+static void (*do_write_64) (unsigned char *ptr, uint64_t val);
+
+static inline uint16_t
+buf_read_ule16 (unsigned char *data)
+{
+ return data[0] | (data[1] << 8);
+}
+
+static inline uint16_t
+buf_read_ube16 (unsigned char *data)
+{
+ return data[1] | (data[0] << 8);
+}
+
+static inline uint32_t
+buf_read_ule32 (unsigned char *data)
+{
+ return (data[0] | (data[1] << 8) | (data[2] << 16)
+ | ((unsigned int)data[3] << 24));
+}
+
+static inline uint32_t
+buf_read_ube32 (unsigned char *data)
+{
+ return (data[3] | (data[2] << 8) | (data[1] << 16)
+ | ((unsigned int)data[0] << 24));
+}
+
+static inline uint64_t
+buf_read_ule64 (unsigned char *data)
+{
+ return buf_read_ule32 (data)
+ | (((uint64_t) buf_read_ule32 (data + 4)) << 32);
+}
+
+static inline uint64_t
+buf_read_ube64 (unsigned char *data)
+{
+ return (((uint64_t) buf_read_ube32 (data)) << 32)
+ | buf_read_ube32 (data + 4);
+}
+
+#define read_8(ptr) *ptr++
+
+#define read_16(ptr) ({ \
+ uint16_t ret = do_read_16 (ptr); \
+ ptr += 2; \
+ ret; \
+})
+
+#define read_32(ptr) ({ \
+ uint32_t ret = do_read_32 (ptr); \
+ ptr += 4; \
+ ret; \
+})
+
+#define read_64(ptr) ({ \
+ uint64_t ret = do_read_64 (ptr); \
+ ptr += 8; \
+ ret; \
+})
+
+#define write_8(ptr, val) \
+ do \
+ *ptr++ = (val); \
+ while (0)
+
+#define write_16(ptr, val) \
+ do \
+ { \
+ do_write_16 (ptr, val); \
+ ptr += 2; \
+ } \
+ while (0)
+
+#define write_32(ptr, val) \
+ do \
+ { \
+ do_write_32 (ptr, val); \
+ ptr += 4; \
+ } \
+ while (0)
+
+#define write_64(ptr, val) \
+ do \
+ { \
+ do_write_64 (ptr, val); \
+ ptr += 8; \
+ } \
+ while (0)
+
+static uint64_t
+read_size (unsigned char *p, int size)
+{
+ switch (size)
+ {
+ case 1: return read_8 (p);
+ case 2: return read_16 (p);
+ case 4: return read_32 (p);
+ case 8: return read_64 (p);
+ default: abort ();
+ }
+}
+
+static void
+write_size (unsigned char *p, int size, uint64_t val)
+{
+ switch (size)
+ {
+ case 1: write_8 (p, val); break;
+ case 2: write_16 (p, val); break;
+ case 4: write_32 (p, val); break;
+ case 8: write_64 (p, val); break;
+ default: abort ();
+ }
+}
+
+static void
+buf_write_le16 (unsigned char *p, unsigned short v)
+{
+ p[0] = v;
+ p[1] = v >> 8;
+}
+
+static void
+buf_write_be16 (unsigned char *p, unsigned short v)
+{
+ p[1] = v;
+ p[0] = v >> 8;
+}
+
+static void
+buf_write_le32 (unsigned char *p, unsigned int v)
+{
+ p[0] = v;
+ p[1] = v >> 8;
+ p[2] = v >> 16;
+ p[3] = v >> 24;
+}
+
+static void
+buf_write_be32 (unsigned char *p, unsigned int v)
+{
+ p[3] = v;
+ p[2] = v >> 8;
+ p[1] = v >> 16;
+ p[0] = v >> 24;
+}
+
+static void
+buf_write_le64 (unsigned char *data, uint64_t v)
+{
+ buf_write_le32 (data, v);
+ buf_write_le32 (data + 4, v >> 32);
+}
+
+static void
+buf_write_be64 (unsigned char *data, uint64_t v)
+{
+ buf_write_be32 (data, v >> 32);
+ buf_write_be32 (data + 4, v);
+}
+
+/* Return a DW_FORM_* name. */
+static const char *
+get_DW_FORM_str (unsigned int form)
+{
+ const char *name = get_DW_FORM_name (form);
+ static char buf[9 + 3 * sizeof (int)];
+ if (name)
+ return name;
+ sprintf (buf, "DW_FORM_%u", form);
+ return buf;
+}
+
+/* Return a DW_OP_* name. */
+static const char *
+get_DW_OP_str (unsigned int op)
+{
+ const char *name = get_DW_OP_name (op);
+ static char buf[7 + 3 * sizeof (int)];
+ if (name)
+ return name;
+ sprintf (buf, "DW_OP_%u", op);
+ return buf;
+}
+
+/* Return a DW_AT_* name. */
+static const char *
+get_DW_AT_str (unsigned int at)
+{
+ const char *name = get_DW_AT_name (at);
+ static char buf[7 + 3 * sizeof (int)];
+ if (name)
+ return name;
+ sprintf (buf, "DW_AT_%u", at);
+ return buf;
+}
+
+/* Return a DW_UT_* name. */
+static const char *
+get_DW_UT_str (unsigned int ut)
+{
+ const char *name = get_DW_UT_name (ut);
+ static char buf[7 + 3 * sizeof (int)];
+ if (name)
+ return name;
+ sprintf (buf, "DW_UT_%u", ut);
+ return buf;
+}
+
+/* Retrun a DW_LNCT_* name. */
+static const char *
+get_DW_LNCT_str (unsigned int lnct)
+{
+ const char *name;
+ static char buf[9 + 3 * sizeof (int)];
+ switch (lnct)
+ {
+ case DW_LNCT_path: name = "DW_LNCT_path"; break;
+ case DW_LNCT_directory_index: name = "DW_LNCT_directory_index"; break;
+ case DW_LNCT_timestamp: name = "DW_LNCT_timestamp"; break;
+ case DW_LNCT_size: name = "DW_LNCT_size"; break;
+ case DW_LNCT_MD5: name = "DW_LNCT_MD5"; break;
+
+ default: name = 0; break;
+ }
+ if (name)
+ return name;
+ sprintf (buf, "DW_LNCT_%u", lnct);
+ return buf;
+}
+
+/* This must match the debug_sections array content
+ below. */
+enum debug_section_kind
+{
+ DEBUG_INFO,
+ DEBUG_ABBREV,
+ DEBUG_LINE,
+ DEBUG_STR,
+ DEBUG_MACRO,
+ DEBUG_TYPES,
+ DEBUG_ARANGES,
+ DEBUG_PUBNAMES,
+ DEBUG_PUBTYPES,
+ DEBUG_GNU_PUBNAMES,
+ DEBUG_GNU_PUBTYPES,
+ DEBUG_MACINFO,
+ DEBUG_LOC,
+ DEBUG_LOCLISTS,
+ DEBUG_FRAME,
+ DEBUG_RANGES,
+ DEBUG_RNGLISTS,
+ DEBUG_LINE_STR,
+ DEBUG_SUP,
+ DEBUG_GDB_SCRIPTS,
+ GDB_INDEX,
+ GNU_DEBUGALTLINK,
+ SECTION_COUNT,
+ SAVED_SECTIONS = DEBUG_TYPES + 1
+};
+
+/* Details about standard DWARF sections. */
+static struct
+{
+ const char *name;
+ unsigned char *data;
+ unsigned char *new_data;
+ size_t size;
+ size_t new_size;
+ int sec;
+} debug_sections[] =
+ {
+ { ".debug_info", NULL, NULL, 0, 0, 0 },
+ { ".debug_abbrev", NULL, NULL, 0, 0, 0 },
+ { ".debug_line", NULL, NULL, 0, 0, 0 },
+ { ".debug_str", NULL, NULL, 0, 0, 0 },
+ { ".debug_macro", NULL, NULL, 0, 0, 0 },
+ { ".debug_types", NULL, NULL, 0, 0, 0 },
+ { ".debug_aranges", NULL, NULL, 0, 0, 0 },
+ { ".debug_pubnames", NULL, NULL, 0, 0, 0 },
+ { ".debug_pubtypes", NULL, NULL, 0, 0, 0 },
+ { ".debug_gnu_pubnames", NULL, NULL, 0, 0, 0 },
+ { ".debug_gnu_pubtypes", NULL, NULL, 0, 0, 0 },
+ { ".debug_macinfo", NULL, NULL, 0, 0, 0 },
+ { ".debug_loc", NULL, NULL, 0, 0, 0 },
+ { ".debug_loclists", NULL, NULL, 0, 0, 0 },
+ { ".debug_frame", NULL, NULL, 0, 0, 0 },
+ { ".debug_ranges", NULL, NULL, 0, 0, 0 },
+ { ".debug_rnglists", NULL, NULL, 0, 0, 0 },
+ { ".debug_line_str", NULL, NULL, 0, 0, 0 },
+ { ".debug_sup", NULL, NULL, 0, 0, 0 },
+ { ".debug_gdb_scripts", NULL, NULL, 0, 0, 0 },
+ { ".gdb_index", NULL, NULL, 0, 0, 0 },
+ { ".gnu_debugaltlink", NULL, NULL, 0, 0, 0 },
+ { NULL, NULL, NULL, 0, 0, 0 }
+ };
+
+/* Copies of .new_data fields during write_multifile. */
+static unsigned char *saved_new_data[SAVED_SECTIONS];
+/* Copies of .new_size fields during write_multifile. */
+static size_t saved_new_size[SAVED_SECTIONS];
+
+/* Copies of .data fields after read_multifile. */
+static unsigned char *alt_data[SAVED_SECTIONS];
+/* Copies of .size fields after read_multifile. */
+static size_t alt_size[SAVED_SECTIONS];
+
+/* How many bytes of each of /tmp/dwz.debug_*.XXXXXX have we written
+ already. */
+static unsigned int multi_info_off, multi_abbrev_off;
+static unsigned int multi_line_off, multi_str_off;
+static unsigned int multi_macro_off;
+/* And corresponding file descriptors. */
+static int multi_info_fd = -1, multi_abbrev_fd = -1;
+static int multi_line_fd = -1, multi_str_fd = -1;
+static int multi_macro_fd = -1;
+
+/* Copy of one of the input file's ehdr. */
+static GElf_Ehdr multi_ehdr;
+
+/* Pointer size of all debug info sources accumulated during
+ write_multifile. */
+static int multi_ptr_size;
+/* And their endianity. */
+static int multi_endian;
+/* Highest .gdb_index version seen. */
+static unsigned int multi_gdb_index_ver;
+
+enum multifile_mode_kind
+{
+ MULTIFILE_MODE_WR = 1,
+ MULTIFILE_MODE_OP = 2,
+ MULTIFILE_MODE_RD = 4,
+ MULTIFILE_MODE_FI = 8,
+ MULTIFILE_MODE_LOW_MEM = 16
+};
+
+/* True while in write_multifile. */
+#define wr_multifile (multifile_mode & MULTIFILE_MODE_WR)
+
+/* True while in optimize_multifile. */
+#define op_multifile (multifile_mode & MULTIFILE_MODE_OP)
+
+/* True while in read_multifile. */
+#define rd_multifile (multifile_mode & MULTIFILE_MODE_RD)
+
+/* True while in finalize_multifile. */
+#define fi_multifile (multifile_mode & MULTIFILE_MODE_FI)
+
+/* True if running in low_mem mode. */
+#define low_mem (multifile_mode & MULTIFILE_MODE_LOW_MEM)
+
+/* SHA1 checksum (build-id) of the common file. */
+static unsigned char multifile_sha1[0x14];
+
+/* A single attribute in abbreviations. */
+struct abbrev_attr
+{
+ /* DW_AT_* attribute code. */
+ unsigned int attr;
+ /* DW_FORM_* form code. */
+ unsigned int form;
+};
+
+/* Internal structure for .debug_abbrev entries. */
+struct abbrev_tag
+{
+ /* Abbreviation number. */
+ unsigned int entry;
+ /* Hash value, in first abbrev hash tables it is
+ the same as entry, in cu->cu_new_abbrev hash tables
+ iterative hash of all the relevant values. */
+ hashval_t hash;
+ /* DW_TAG_* code. */
+ unsigned int tag;
+ /* Number of attributes. */
+ unsigned int nattr;
+ /* How many DIEs refer to this abbreviation (unused
+ in first abbrev hash tables). */
+ unsigned int nusers;
+ /* True if DIEs with this abbreviation have children. */
+ bool children;
+ /* True if any typed DWARF opcodes refer to this. */
+ bool op_type_referenced;
+ /* The values of DW_FORM_implicit_const attribute forms. */
+ int64_t *values;
+ /* Attribute/form pairs. */
+ struct abbrev_attr attr[0];
+};
+
+typedef struct dw_die *dw_die_ref;
+typedef struct dw_cu *dw_cu_ref;
+struct import_cu;
+
+/* An entry from .debug_line file table. */
+struct dw_file
+{
+ char *dir;
+ char *file;
+ uint64_t time, size;
+ unsigned int file_angle_brackets_encapsulated_no_slash : 1;
+};
+
+/* Internal representation of a compilation (or partial)
+ unit. */
+struct dw_cu
+{
+ /* Cached entries from .debug_line file table. */
+ struct dw_file *cu_files;
+ unsigned int cu_nfiles;
+ /* Kind of CU, normal (present in .debug_info), newly created
+ partial unit, .debug_types unit or .debug_info partial unit
+ from the common file. */
+ enum { CU_NORMAL, CU_PU, CU_TYPES, CU_ALT } cu_kind;
+ /* CUs linked from first_cu through this chain. */
+ dw_cu_ref cu_next;
+ /* Offset in original .debug_info if CU_NORMAL or .debug_types
+ if CU_TYPES, otherwise a unique index of the newly created
+ partial CU. */
+ unsigned int cu_offset;
+ /* DWARF version of the CU. */
+ unsigned int cu_version;
+ /* Cached DW_AT_comp_dir value from DW_TAG_*_unit cu_die,
+ or NULL if that attribute is not present. */
+ char *cu_comp_dir;
+ /* Pointer to the DW_TAG_*_unit inside of the .debug_info
+ chunk. */
+ dw_die_ref cu_die;
+ /* The original abbreviation hash table. */
+ htab_t cu_abbrev;
+ /* New abbreviation hash table. */
+ htab_t cu_new_abbrev;
+ union dw_cu_u1
+ {
+ /* Pointer to another struct dw_cu that owns
+ cu_new_abbrev for this CU. */
+ dw_cu_ref cu_new_abbrev_owner;
+ /* Pointer used during create_import_tree. */
+ struct import_cu *cu_icu;
+ } u1;
+ union dw_cu_u2
+ {
+ /* Offset into the new .debug_abbrev section. */
+ unsigned int cu_new_abbrev_offset;
+ /* Highest ->entry value in the new abbrev table
+ For abbrevs computed by this tool it is always
+ equal to the number of abbreviations, but if
+ abbrevs are read for .debug_types section which
+ is not rewritten, there might be holes. */
+ unsigned int cu_largest_entry;
+ } u2;
+ /* Offset into the new .debug_info section. */
+ unsigned int cu_new_offset;
+ /* When op_multifile, record which object this came from here,
+ otherwise it is the index of the CU. */
+ unsigned int cu_chunk;
+ /* Form chosen for intra-cu references. */
+ enum dwarf_form cu_intracu_form;
+ /* Intracusize argument to init_new_die_offsets. Set in compute_abbrevs,
+ used in recompute_abbrevs. */
+ unsigned int initial_intracusize;
+ enum dwarf_source_language lang;
+};
+
+/* Internal representation of a debugging information entry (DIE).
+ This structure should be kept as small as possible,
+ there are .debug_info sections with tens of millions of DIEs
+ in them and this structure is allocated for each of them. */
+struct dw_die
+{
+ /* Offset in old .debug_info from the start of the .debug_info section,
+ -1U for newly created DIEs. */
+ unsigned int die_offset;
+ /* Cached copy of die_abbrev->tag. */
+ enum dwarf_tag die_tag : 16;
+ /* State of checksum computation. Not computed yet, computed and
+ suitable for moving into partial units, currently being computed
+ and finally determined unsuitable for moving into partial units. */
+ enum { CK_UNKNOWN, CK_KNOWN, CK_BEING_COMPUTED, CK_BAD } die_ck_state : 2;
+ /* Set if any DW_OP_call2 opcode refers to this DIE. */
+ unsigned int die_op_call2_referenced : 1;
+ /* Set if any DW_OP_GNU_{{regval,deref,const}_type,convert,reinterpret}
+ opcode refers to this DIE. Only DW_TAG_base_type DIEs should be
+ referenced. As those opcodes refer to them using uleb128, we need to try
+ hard to have those DIEs with low enough offsets that the uleb128 will
+ fit. */
+ unsigned int die_op_type_referenced : 1;
+ /* Set in DW_TAG_namespace or DW_TAG_module with DW_AT_name that is
+ either a child of DW_TAG_*_unit, or a child of another
+ die_named_namespace DIE. */
+ unsigned int die_named_namespace : 1;
+ /* Set if u.p1.die_ref_hash is valid. */
+ unsigned int die_ref_hash_computed : 1;
+ /* Set if die_dup and die_nextdup fields are after this structure.
+ True for DW_TAG_*_unit DIEs, die_named_namespace DIEs and their
+ immediate children. */
+ unsigned int die_toplevel : 1;
+ /* Set if we want to remove this DIE from its containing CU. */
+ unsigned int die_remove : 1;
+ /* Set if DIE is unsuitable for moving into alternate .debug_info. */
+ unsigned int die_no_multifile : 1;
+ /* Set if DIE is referenced using DW_FORM_ref*. So far only used during
+ optimize_multifile and low_mem. */
+ unsigned int die_referenced : 1;
+ /* Set if DIE is referenced using DW_FORM_ref_addr. So far used only
+ during low_mem. */
+ unsigned int die_intercu_referenced : 1;
+ /* Set if DIE has its children collapsed. Only used during
+ optimize_multifile. */
+ unsigned int die_collapsed_children : 1;
+ /* Set on collapsed child DIE that is referenced. In that case, die_tag
+ is reused for die_enter difference from parent and no fields after
+ die_parent are allocated. */
+ unsigned int die_collapsed_child : 1;
+ /* Set if die_parent field is reused for struct dw_cu pointer. */
+ unsigned int die_root : 1;
+ /* State for ODR optimization. */
+ enum { ODR_UNKNOWN, ODR_NONE, ODR_DEF, ODR_DECL } die_odr_state : 2;
+ /* Tree pointer to parent. */
+ dw_die_ref die_parent;
+
+ /* The remaining fields are present only if die_collapsed_child is
+ 0. */
+
+ /* Tree pointers, to first child and pointer to next sibling. */
+ dw_die_ref die_child, die_sib;
+ /* Pointer to the old .debug_abbrev entry's internal representation. */
+ struct abbrev_tag *die_abbrev;
+ /* Size of the DIE (abbrev number + attributes), not including children.
+ In later phases this holds the new size as opposed to the old one. */
+ unsigned int die_size;
+ /* Index into the dw_die_ref vector used in checksum_ref_die function.
+ While this is only phase 1 field, we get better packing by having it
+ here instead of u.p1. */
+ unsigned int die_ref_seen;
+ union dw_die_phase
+ {
+ /* Fields used in the first phase (read_debug_info and partition_dups
+ and functions they call). */
+ struct dw_die_p1
+ {
+ /* Iterative hash value of the tag, attributes other than
+ references or DW_FORM_ref_addr references or references
+ within the subtree of ultimate parent's die_toplevel DIE's
+ children. Computed by checksum_die function. */
+ hashval_t die_hash;
+ /* Iterative hash of other references. Computed by
+ checksum_ref_die function. */
+ hashval_t die_ref_hash;
+ /* For ODR phase 1, we change die_hash for ODR_DEF and ODR_DECL DIEs
+ to only hash in the tag and the name, to be able to construct
+ maximal duplicate chains. But during ODR phase 2, we want to
+ compare ODR_DEF DIEs in the normal way, for which we need the
+ unchanged die_hash, which we store here in die_hash2. */
+ hashval_t die_hash2;
+ /* Tick count of entering and leaving a DIE during depth first
+ traversal of the CU, used to quickly find if a subtree is
+ referenced. */
+ unsigned int die_enter, die_exit;
+ } p1;
+ /* Fields used only after the first phase (from compute_abbrevs
+ till the end). */
+ struct dw_die_p2
+ {
+ /* Pointer to internal representation of new .debug_abbrev
+ entry for this DIE. */
+ struct abbrev_tag *die_new_abbrev;
+ /* Offset within the new .debug_info CU. Unlike die_offset
+ this one is CU relative, so die_cu (die)->cu_new_offset needs
+ to be added to it to get .debug_info offset. */
+ unsigned int die_new_offset;
+ /* Used during compute_abbrevs DW_FORM_ref_udata optimization. */
+ unsigned int die_intracu_udata_size;
+ } p2;
+ } u;
+
+ /* The remaining fields are present only if die_toplevel is
+ 1. */
+
+ /* Pointer to a duplicate DIE. */
+ dw_die_ref die_dup;
+ /* Chain of duplicate DIEs. If die_dup is NULL, but die_nextdup
+ is non-NULL, this is the reference DIE of the duplicates.
+ All DIEs in the die->nextdup linked list have die_dup pointing
+ to this node. The reference DIE is initially just a DIE in the
+ lowest CU that has the matching DIE, later on it is a DIE in
+ the newly created partial unit CU. */
+ dw_die_ref die_nextdup;
+};
+
+#include "iterators.h"
+
+/* Return CU structure pointer for a DIE. In order to save memory,
+ individual DIEs don't have a dw_cu_ref field, and the pointer can
+ be only found by overriding the die_parent pointer in a
+ DW_TAG_{compile,partial}_unit descriptor, which has no parent. */
+static inline dw_cu_ref
+die_cu (dw_die_ref die)
+{
+ while (!die->die_root)
+ die = die->die_parent;
+ return (dw_cu_ref) die->die_parent;
+}
+
+/* Given a toplevel die DIE, return the first (that is, the reference die) in
+ the duplicate chain. */
+#define first_dup(die) \
+ (die->die_dup \
+ ? die->die_dup \
+ : (die->die_nextdup \
+ ? die \
+ : NULL))
+
+/* Safe variant that check die_toplevel. Can't be used on LHS. */
+#define die_safe_dup(die) \
+ ((die)->die_toplevel ? (die)->die_dup : (dw_die_ref) NULL)
+#define die_safe_nextdup(die) \
+ ((die)->die_toplevel ? (die)->die_nextdup : (dw_die_ref) NULL)
+
+ALIGN_STRUCT (abbrev_tag)
+ALIGN_STRUCT (dw_file)
+ALIGN_STRUCT (dw_cu)
+ALIGN_STRUCT (dw_die)
+
+
+/* After read_multifile, pool variable is moved over to this variable
+ as the pool from read_multifile needs to be around for subsequent dwz
+ calls. Freed only during the final cleanup at the very end. */
+static unsigned char *alt_pool;
+
+static struct abbrev_tag *
+pool_clone_abbrev (struct abbrev_tag *t)
+{
+ struct abbrev_tag *newt;
+ size_t newt_size;
+ unsigned nvalue = 0;
+ if (t->values != NULL)
+ {
+ unsigned i;
+ for (i = 0; i < t->nattr; i++)
+ if (t->attr[i].form == DW_FORM_implicit_const)
+ nvalue = i + 1;
+ }
+ newt_size = (sizeof (*newt)
+ + t->nattr * sizeof (struct abbrev_attr)
+ + nvalue * sizeof (int64_t));
+ newt = pool_alloc (abbrev_tag, newt_size);
+ memcpy (newt, t, newt_size - (nvalue * sizeof (int64_t)));
+ if (nvalue == 0)
+ newt->values = NULL;
+ else
+ {
+ newt->values = (int64_t *) &newt->attr[newt->nattr];
+ memcpy (newt->values, t->values, nvalue * sizeof (int64_t));
+ }
+ return newt;
+}
+
+/* Hash function in first abbrev hash table as well as cu->cu_new_abbrev
+ htab. */
+static hashval_t
+abbrev_hash (const void *p)
+{
+ struct abbrev_tag *t = (struct abbrev_tag *)p;
+
+ return t->hash;
+}
+
+/* Equality function in first abbrev htab. */
+static int
+abbrev_eq (const void *p, const void *q)
+{
+ struct abbrev_tag *t1 = (struct abbrev_tag *)p;
+ struct abbrev_tag *t2 = (struct abbrev_tag *)q;
+
+ return t1->entry == t2->entry;
+}
+
+/* Equality function in cu->cu_new_abbrev htab. */
+static int
+abbrev_eq2 (const void *p, const void *q)
+{
+ struct abbrev_tag *t1 = (struct abbrev_tag *)p;
+ struct abbrev_tag *t2 = (struct abbrev_tag *)q;
+ unsigned int i;
+
+ if (t1->hash != t2->hash
+ || t1->tag != t2->tag
+ || t1->nattr != t2->nattr
+ || t1->children != t2->children)
+ return 0;
+ for (i = 0; i < t1->nattr; i++)
+ if (t1->attr[i].attr != t2->attr[i].attr
+ || t1->attr[i].form != t2->attr[i].form
+ || (t1->attr[i].form == DW_FORM_implicit_const
+ && t1->values[i] != t2->values[i]))
+ return 0;
+ return 1;
+}
+
+/* Helper function to compute abbrev entry iterative hash value. */
+static void
+compute_abbrev_hash (struct abbrev_tag *t)
+{
+ unsigned int i;
+
+ hash_init_state ();
+ hash_update_state_object (t->tag);
+ hash_update_state_object (t->nattr);
+ hash_update_state_object (t->children);
+ for (i = 0; i < t->nattr; i++)
+ {
+ hash_update_state_object (t->attr[i].attr);
+ hash_update_state_object (t->attr[i].form);
+ if (t->attr[i].form == DW_FORM_implicit_const)
+ hash_update_state_object (t->values[i]);
+ }
+ t->hash = hash_digest ();
+}
+
+/* Maximum number of attributes in a DIE. */
+static unsigned int max_nattr;
+
+/* Parse a .debug_abbrev entry at PTR. */
+static htab_t
+read_abbrev (DSO *dso, unsigned char *ptr)
+{
+ htab_t h;
+ unsigned int attr, form;
+ struct abbrev_tag *t;
+ void **slot;
+
+ h = htab_try_create (50, abbrev_hash, abbrev_eq, NULL);
+ if (h == NULL)
+ dwz_oom ();
+
+ while ((attr = read_uleb128 (ptr)) != 0)
+ {
+ int highest_implicit_value_ndx = -1;
+ unsigned int nattr = 0;
+ unsigned char *p = ptr;
+
+ skip_leb128 (p);
+ p++;
+ while (read_uleb128 (p) != 0)
+ {
+ nattr++;
+ form = read_uleb128 (p);
+ if (form == DW_FORM_implicit_const)
+ {
+ skip_leb128 (p);
+ highest_implicit_value_ndx = nattr - 1;
+ }
+ else if (form == 2
+ || (form > DW_FORM_flag_present
+ && !(form == DW_FORM_ref_sig8
+ || form == DW_FORM_data16
+ || form == DW_FORM_line_strp)))
+ {
+ error (0, 0, "%s: Unknown DWARF %s at .debug_abbrev [%zd]",
+ dso->filename, get_DW_FORM_str (form),
+ p - debug_sections[DEBUG_ABBREV].data);
+ htab_delete (h);
+ return NULL;
+ }
+ }
+ if (read_uleb128 (p) != 0)
+ {
+ error (0, 0, "%s: DWARF abbreviation does not end with 2 zeros",
+ dso->filename);
+ htab_delete (h);
+ return NULL;
+ }
+
+ t = pool_alloc (abbrev_tag,
+ sizeof (*t) + nattr * sizeof (struct abbrev_attr)
+ + sizeof (int64_t) * (highest_implicit_value_ndx + 1));
+ t->entry = attr;
+ t->hash = attr;
+ t->nattr = nattr;
+ t->nusers = 0;
+ t->tag = read_uleb128 (ptr);
+ t->children = *ptr++ == DW_CHILDREN_yes;
+ t->op_type_referenced = false;
+ t->values = (highest_implicit_value_ndx >= 0
+ ? (int64_t *) &t->attr[nattr] : NULL);
+ nattr = 0;
+ while ((attr = read_uleb128 (ptr)) != 0)
+ {
+ form = read_uleb128 (ptr);
+ if (form == DW_FORM_implicit_const)
+ t->values[nattr] = read_sleb128 (ptr);
+ t->attr[nattr].attr = attr;
+ t->attr[nattr++].form = form;
+ }
+ skip_leb128 (ptr);
+ if (t->nattr > max_nattr)
+ max_nattr = t->nattr;
+ slot = htab_find_slot_with_hash (h, t, t->hash, INSERT);
+ if (slot == NULL)
+ {
+ htab_delete (h);
+ dwz_oom ();
+ }
+ if (*slot != NULL)
+ {
+ error (0, 0, "%s: Duplicate DWARF abbreviation %d", dso->filename,
+ t->entry);
+ htab_delete (h);
+ return NULL;
+ }
+ *slot = t;
+ }
+
+ return h;
+}
+
+/* For a die attribute with form FORM starting at PTR, with the die in CU,
+ return the pointer after the attribute, assuming FORM is not
+ dw_form_indirect. */
+static inline unsigned char * FORCE_INLINE
+skip_attr_no_dw_form_indirect (unsigned int cu_version, uint32_t form,
+ unsigned char *ptr)
+{
+ size_t len = 0;
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ ptr += cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_addr:
+ ptr += ptr_size;
+ break;
+ case DW_FORM_flag_present:
+ case DW_FORM_implicit_const:
+ break;
+ case DW_FORM_ref1:
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ ++ptr;
+ break;
+ case DW_FORM_ref2:
+ case DW_FORM_data2:
+ ptr += 2;
+ break;
+ case DW_FORM_ref4:
+ case DW_FORM_data4:
+ case DW_FORM_sec_offset:
+ case DW_FORM_strp:
+ case DW_FORM_line_strp:
+ ptr += 4;
+ break;
+ case DW_FORM_ref8:
+ case DW_FORM_data8:
+ case DW_FORM_ref_sig8:
+ ptr += 8;
+ break;
+ case DW_FORM_data16:
+ ptr += 16;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_ref_udata:
+ case DW_FORM_udata:
+ skip_leb128 (ptr);
+ break;
+ case DW_FORM_string:
+ ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ case DW_FORM_block1:
+ len = *ptr++;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block:
+ case DW_FORM_exprloc:
+ len = read_uleb128 (ptr);
+ form = DW_FORM_block1;
+ break;
+ default:
+ abort ();
+ }
+
+ if (form == DW_FORM_block1)
+ ptr += len;
+
+ return ptr;
+}
+
+/* Read the directory and file table from .debug_line offset OFF,
+ record it in CU. */
+static int
+read_debug_line (DSO *dso, dw_cu_ref cu, uint32_t off)
+{
+ unsigned char *ptr = debug_sections[DEBUG_LINE].data, *dir, *file;
+ unsigned char **dirt;
+ unsigned char *endsec = ptr + debug_sections[DEBUG_LINE].size;
+ unsigned char *endcu, *endprol;
+ unsigned char opcode_base;
+ unsigned int culen;
+ uint32_t value, version, ndirs, nfiles, dirt_cnt, file_cnt;
+ /* DWARF5 has a dynamic table of elements in possible different
+ forms. But we are only interested in the known elements (path,
+ dir index, time, size and possibly later md5). */
+ unsigned char n, nelems = 0;
+ int path_ndx = -1;
+ int dir_ndx = -1;
+ int time_ndx = -1;
+ int size_ndx = -1;
+ uint16_t elems[256];
+
+ if (off >= debug_sections[DEBUG_LINE].size - 4)
+ {
+ error (0, 0, "%s: .debug_line reference above end of section",
+ dso->filename);
+ return 1;
+ }
+
+ ptr += off;
+
+ endcu = ptr + 4;
+ culen = read_32 (ptr);
+ if (culen >= 0xfffffff0)
+ {
+ error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+ return 1;
+ }
+ endcu += culen;
+
+ if (endcu > endsec)
+ {
+ error (0, 0, "%s: .debug_line CU does not fit into section",
+ dso->filename);
+ return 1;
+ }
+
+ value = read_16 (ptr);
+ if (value < 2 || value > 5)
+ {
+ error (0, 0, "%s: DWARF version %d in .debug_line unhandled",
+ dso->filename, value);
+ return 1;
+ }
+ version = value;
+
+ if (version < lowest_line_version)
+ lowest_line_version = version;
+
+ if (version >= 5)
+ {
+ int addr_size, seg_size;
+ if (ptr + 2 > endcu)
+ {
+ error (0, 0, "%s: .debug_line header too short", dso->filename);
+ return 1;
+ }
+ addr_size = *ptr++;
+ seg_size = *ptr++;
+ if (addr_size != ptr_size)
+ {
+ error (0, 0, "%s: .debug_line address size differs from CU ptr size",
+ dso->filename);
+ return 1;
+ }
+ if (seg_size != 0)
+ {
+ error (0, 0, "%s: .debug_line non-zero segment selector size",
+ dso->filename);
+ return 1;
+ }
+ }
+
+ endprol = ptr + 4;
+ endprol += read_32 (ptr);
+ if (endprol > endcu)
+ {
+ error (0, 0, "%s: .debug_line CU prologue does not fit into CU",
+ dso->filename);
+ return 1;
+ }
+
+ opcode_base = ptr[4 + (version >= 4)];
+ ptr = dir = ptr + 4 + (version >= 4) + opcode_base;
+
+ /* dir table: */
+ if (version < 5)
+ {
+ value = 1;
+ while (*ptr != 0)
+ {
+ ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+ ++value;
+ }
+ ndirs = value;
+ }
+ else
+ {
+ nelems = *ptr++;
+ for (n = 0; n < nelems; n++)
+ {
+ uint16_t lnct = read_uleb128 (ptr);
+ uint16_t form = read_uleb128 (ptr);
+ if (lnct == DW_LNCT_path)
+ {
+ if (path_ndx != -1)
+ {
+ error (0, 0, "%s: .debug_line duplicate dir path elements",
+ dso->filename);
+ return 1;
+ }
+ path_ndx = n;
+ }
+ else
+ {
+ error (0, 0, "%s: .debug_line unhandled dir element %s",
+ dso->filename, get_DW_LNCT_str (lnct));
+ return 1;
+ }
+
+ if (form != DW_FORM_string
+ && form != DW_FORM_strp
+ && form != DW_FORM_line_strp)
+ {
+ error (0, 0, "%s: .debug_line unhandled form %s for dir path",
+ dso->filename, get_DW_FORM_str (form));
+ return 1;
+ }
+
+ elems[n] = form;
+ }
+
+ ndirs = read_uleb128 (ptr);
+ }
+
+ dirt = (unsigned char **) alloca (ndirs * sizeof (unsigned char *));
+ if (version < 5)
+ {
+ dirt[0] = NULL;
+ dirt_cnt = 1;
+ ptr = dir;
+ while (*ptr != 0)
+ {
+ dirt[dirt_cnt++] = ptr;
+ ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+ }
+ ptr++;
+ }
+ else
+ {
+ for (dirt_cnt = 0; dirt_cnt < ndirs; dirt_cnt++)
+ {
+ for (n = 0; n < nelems; n++)
+ {
+ uint32_t form = elems[n];
+ if (n == path_ndx)
+ {
+ unsigned char *d;
+ switch (form)
+ {
+ case DW_FORM_string:
+ d = (unsigned char *) ptr;
+ break;
+ case DW_FORM_strp:
+ {
+ unsigned int strp = do_read_32 (ptr);
+ if (strp >= debug_sections[DEBUG_STR].size)
+ d = NULL;
+ else
+ d = ((unsigned char *)
+ debug_sections[DEBUG_STR].data
+ + strp);
+ }
+ break;
+ case DW_FORM_line_strp:
+ {
+ unsigned int line_strp = do_read_32 (ptr);
+ if (line_strp >= debug_sections[DEBUG_LINE_STR].size)
+ d = NULL;
+ else
+ d = ((unsigned char *)
+ debug_sections[DEBUG_LINE_STR].data
+ + line_strp);
+ }
+ break;
+ default:
+ d = NULL;
+ break;
+ }
+
+ if (d == NULL)
+ {
+ error (0, 0, "%s: .debug_line bad dir path",
+ dso->filename);
+ return 1;
+ }
+
+ /* Note we do this even for the zero entry, which is
+ marked as NULL for pre-DWARF5 line tables. This
+ is important for when we merge file entries
+ together for a multifile because the zero dir
+ entry could differ. It is should be equivalent
+ to the CU DIE comp_dir attribute, but we don't
+ track that all CUs referring to the (same) line
+ table share identical an DW_AT_comp_dir value. */
+ dirt[dirt_cnt] = d;
+ }
+ ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+ }
+ }
+ }
+
+ /* file table: */
+ file = ptr;
+ if (version < 5)
+ {
+ file_cnt = 0;
+ while (*ptr != 0)
+ {
+ ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+ value = read_uleb128 (ptr);
+
+ if (value >= dirt_cnt)
+ {
+ error (0, 0, "%s: Wrong directory table index %u",
+ dso->filename, value);
+ return 1;
+ }
+
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ file_cnt++;
+ }
+ nfiles = file_cnt;
+ }
+ else
+ {
+ nelems = *ptr++;
+ path_ndx = -1;
+ for (n = 0; n < nelems; n++)
+ {
+ uint16_t lnct = read_uleb128 (ptr);
+ uint16_t form = read_uleb128 (ptr);
+ switch (lnct)
+ {
+ case DW_LNCT_path:
+ if (path_ndx != -1)
+ {
+ error (0, 0,
+ "%s: .debug_line duplicate file path elements",
+ dso->filename);
+ return 1;
+ }
+ path_ndx = n;
+
+ /* Currently we only handle two string form which always
+ stay... */
+ if (form != DW_FORM_string && form != DW_FORM_line_strp)
+ {
+ error (0, 0,
+ "%s: .debug_line unhandled form %s for file path",
+ dso->filename, get_DW_FORM_str (form));
+ return 1;
+ }
+ break;
+
+ case DW_LNCT_directory_index:
+ if (dir_ndx != -1)
+ {
+ error (0, 0,
+ "%s: .debug_line duplicate file dir elements",
+ dso->filename);
+ return 1;
+ }
+ dir_ndx = n;
+
+ if (form != DW_FORM_data1
+ && form != DW_FORM_data2
+ && form != DW_FORM_udata)
+ {
+ error (0, 0,
+ "%s: .debug_line unhandled form %s for dir index",
+ dso->filename, get_DW_FORM_str (form));
+ return 1;
+ }
+ break;
+
+ case DW_LNCT_timestamp:
+ if (time_ndx != -1)
+ {
+ error (0, 0,
+ "%s: .debug_line duplicate file time elements",
+ dso->filename);
+ return 1;
+ }
+ time_ndx = n;
+
+ if (form != DW_FORM_udata
+ && form != DW_FORM_data4
+ && form != DW_FORM_data8)
+ {
+ error (0, 0,
+ "%s: .debug_line unhandled form %s for file time",
+ dso->filename, get_DW_FORM_str (form));
+ return 1;
+ }
+ break;
+
+ case DW_LNCT_size:
+ if (size_ndx != -1)
+ {
+ error (0, 0,
+ "%s: .debug_line duplicate file size elements",
+ dso->filename);
+ return 1;
+ }
+ size_ndx = n;
+
+ if (form != DW_FORM_udata
+ && form != DW_FORM_data1
+ && form != DW_FORM_data2
+ && form != DW_FORM_data4
+ && form != DW_FORM_data8)
+ {
+ error (0, 0,
+ "%s: .debug_line unhandled form %s for file size",
+ dso->filename, get_DW_FORM_str (form));
+ return 1;
+ }
+ break;
+
+ default:
+ error (0, 0, "%s: .debug_line unhandled file element %s",
+ dso->filename, get_DW_LNCT_str (lnct));
+ return 1;
+ }
+ elems[n] = form;
+ }
+
+ nfiles = read_uleb128 (ptr);
+ if (nfiles > 0)
+ nfiles--; /* We will skip the first (zero) entry. */
+ }
+
+ cu->cu_nfiles = nfiles;
+ cu->cu_files = pool_alloc (dw_file, nfiles * sizeof (struct dw_file));
+ memset (cu->cu_files, 0, nfiles * sizeof (struct dw_file));
+
+ if (version < 5)
+ ptr = file;
+
+ for (file_cnt = 0; file_cnt < nfiles; file_cnt++)
+ {
+ char *f = NULL;
+ char *end = NULL;
+ uint32_t d = 0;
+ uint64_t time = 0;
+ uint64_t size = 0;
+ if (version < 5)
+ {
+ f = (char *) ptr;
+ ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1;
+ end = (char *) ptr;
+ d = read_uleb128 (ptr);
+ time = read_uleb128 (ptr);
+ size = read_uleb128 (ptr);
+ }
+ else
+ {
+ /* Skip zero entry. */
+ if (file_cnt == 0)
+ for (n = 0; n < nelems; n++)
+ ptr = skip_attr_no_dw_form_indirect (cu->cu_version,
+ elems[n], ptr);
+
+ for (n = 0; n < nelems; n++)
+ {
+ uint32_t form = elems[n];
+ if (n == path_ndx)
+ {
+ switch (form)
+ {
+ case DW_FORM_string:
+ f = (char *) ptr;
+ end = strchr ((char *)ptr, 0) + 1;
+ break;
+ case DW_FORM_strp:
+ {
+ unsigned int strp = do_read_32 (ptr);
+ if (strp >= debug_sections[DEBUG_STR].size)
+ f = NULL;
+ else
+ {
+ f = ((char *) debug_sections[DEBUG_STR].data
+ + strp);
+ end = f + strlen (f) + 1;
+ }
+ }
+ break;
+ case DW_FORM_line_strp:
+ {
+ unsigned int line_strp = do_read_32 (ptr);
+ if (line_strp >= debug_sections[DEBUG_LINE_STR].size)
+ f = NULL;
+ else
+ {
+ f = ((char *) debug_sections[DEBUG_LINE_STR].data
+ + line_strp);
+ end = f + strlen (f) + 1;
+ }
+ }
+ break;
+ default:
+ f = NULL;
+ break;
+ }
+
+ if (f == NULL)
+ {
+ error (0, 0, "%s: .debug_line bad file path",
+ dso->filename);
+ return 1;
+ }
+ }
+ else if (n == dir_ndx)
+ {
+ switch (form)
+ {
+ case DW_FORM_data1:
+ d = *ptr;
+ break;
+ case DW_FORM_data2:
+ d = do_read_16 (ptr);
+ break;
+ case DW_FORM_udata:
+ {
+ unsigned char *p = ptr;
+ d = read_uleb128 (p);
+ }
+ break;
+ }
+ }
+ ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+ }
+ }
+
+ cu->cu_files[file_cnt].file = f;
+ if (d >= dirt_cnt)
+ {
+ error (0, 0, "%s: Wrong directory table index %u",
+ dso->filename, value);
+ return 1;
+ }
+
+ cu->cu_files[file_cnt].dir = (char *) dirt[d];
+ cu->cu_files[file_cnt].time = time;
+ cu->cu_files[file_cnt].size = size;
+ size_t file_len = (char *) end - f;
+ size_t strlen_file = file_len - 1;
+ bool file_has_slash = false;
+ if (cu->cu_files[file_cnt].file[0] != '/'
+ && cu->cu_files[file_cnt].dir != NULL)
+ {
+ size_t dir_len = strlen (cu->cu_files[file_cnt].dir);
+ if (dir_len)
+ {
+ obstack_grow (&ob, cu->cu_files[file_cnt].dir,
+ dir_len);
+ strlen_file += dir_len;
+ if (cu->cu_files[file_cnt].dir[dir_len - 1] != '/')
+ {
+ obstack_1grow (&ob, '/');
+ strlen_file++;
+ }
+ file_has_slash = true;
+ obstack_grow (&ob, cu->cu_files[file_cnt].file,
+ file_len);
+ cu->cu_files[file_cnt].file
+ = (char *) obstack_finish (&ob);
+ cu->cu_files[file_cnt].dir = NULL;
+ }
+ }
+ cu->cu_files[file_cnt].file_angle_brackets_encapsulated_no_slash
+ = (!file_has_slash
+ && cu->cu_files[file_cnt].file[0] == '<'
+ && cu->cu_files[file_cnt].file[strlen_file - 1] == '>'
+ && strchr (cu->cu_files[file_cnt].file, '/') == NULL);
+ }
+
+ return 0;
+}
+
+/* Estimate the amount of DIEs in the .debug_info section, based on the size
+ of that section. */
+static unsigned int
+estimate_nr_dies (void)
+{
+ unsigned int average_die_size = 11;
+ unsigned int nr_dies = debug_sections[DEBUG_INFO].size / average_die_size;
+ return nr_dies;
+}
+
+static size_t
+emulate_htab (size_t initial, size_t final_nr_elements)
+{
+ size_t size = initial;
+
+ /* Emulate creation. */
+ size = higher_prime_number (size);
+
+ /* Emulate growing till htab contains find_nr_elements. */
+ while (1)
+ {
+ /* Emulate expansion trigger. */
+ size_t nr_elements = size * 3 / 4;
+ while (!(size * 3 <= nr_elements * 4))
+ nr_elements++;
+
+ if (nr_elements > final_nr_elements)
+ {
+ nr_elements = final_nr_elements;
+ break;
+ }
+
+ /* Emulate expansion. */
+ size = size * 2;
+ size = higher_prime_number (size);
+ }
+
+ return size;
+}
+
+/* Print hash table statistics for hash table HTAB with message string MSG. */
+static void
+htab_report (htab_t htab, const char *msg)
+{
+ double collisions = htab_collisions (htab);
+ unsigned int searches = htab->searches;
+ size_t elements = htab->n_elements;
+ size_t deleted = htab->n_deleted;
+ size_t adjusted_elements = elements - deleted;
+ size_t size = htab->size;
+ double occupancy = (double)elements / (double)size;
+ double adjusted_occupancy = (double)adjusted_elements / (double)size;
+ /* Indent unconditional fprintfs similar to conditional fprintfs to
+ left-align literal strings. */
+ if (1)
+ fprintf (stderr, "htab: %s\n", msg);
+ if (1)
+ fprintf (stderr, " size: %zu\n", size);
+ if (elements > 0 && deleted == 0)
+ fprintf (stderr, " elements: %zu, occupancy: %f\n", elements,
+ occupancy);
+ if (deleted > 0)
+ fprintf (stderr, " elements (incl. deleted): %zu, occupancy: %f\n",
+ elements, occupancy);
+ if (deleted > 0)
+ fprintf (stderr, " elements (excl. deleted): %zu, occupancy: %f\n",
+ adjusted_elements, adjusted_occupancy);
+ if (elements > 0)
+ fprintf (stderr, " searches: %u, collisions: %f\n", searches,
+ collisions);
+}
+
+/* Hash function for off_htab hash table. */
+static hashval_t
+off_hash (const void *p)
+{
+ dw_die_ref die = (dw_die_ref) p;
+
+ return die->die_offset / 6;
+}
+
+/* Equality function for off_htab hash table. */
+static int
+off_eq (const void *p, const void *q)
+{
+ return ((dw_die_ref) p)->die_offset == ((dw_die_ref) q)->die_offset;
+}
+
+/* Hash table to map die_offset values to struct dw_die pointers. */
+static htab_t off_htab;
+
+/* After read_multifile off_htab is copied over to this variable.
+ Offsets in the alternate .debug_info are found using this hash table. */
+static htab_t alt_off_htab;
+
+/* Offset hash table for .debug_types section. */
+static htab_t types_off_htab;
+
+/* Function to add DIE into the hash table (and create the hash table
+ when not already created). */
+static void
+off_htab_add_die (dw_cu_ref cu, dw_die_ref die, unsigned int *die_count)
+{
+ void **slot;
+
+ if (unlikely (cu->cu_kind == CU_TYPES))
+ {
+ if (types_off_htab == NULL)
+ {
+ types_off_htab = htab_try_create (100000, off_hash, off_eq, NULL);
+ if (types_off_htab == NULL)
+ dwz_oom ();
+ }
+
+ slot = htab_find_slot (types_off_htab, die, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ assert (*slot == NULL);
+ *slot = die;
+ return;
+ }
+
+ if (off_htab == NULL)
+ {
+ unsigned int estimated_nr_dies = estimate_nr_dies ();
+ size_t default_initial_size = 100000;
+ size_t initial_size;
+ if (low_mem
+ || op_multifile
+ || (multifile_mode == 0
+ && die_count_method == estimate
+ && (estimated_nr_dies >= low_mem_die_limit
+ || estimated_nr_dies >= max_die_limit)))
+ initial_size = default_initial_size;
+ else
+ {
+ size_t nr_dies;
+ if (die_count && *die_count != 0)
+ {
+ nr_dies = *die_count;
+ if (tracing)
+ fprintf (stderr, "Using die count %zu for off_htab"
+ " allocation\n", nr_dies);
+ }
+ else if (die_count_method == none)
+ nr_dies = 0;
+ else if (die_count_method == estimate)
+ {
+ nr_dies = estimated_nr_dies;
+ if (tracing)
+ fprintf (stderr, "Using die count estimate %zu for off_htab"
+ " allocation\n", nr_dies);
+ }
+ else
+ assert (false);
+
+ if (nr_dies != 0)
+ {
+ size_t final_hashtab_size
+ = emulate_htab (default_initial_size, nr_dies);
+ initial_size = final_hashtab_size;
+ }
+ else
+ initial_size = default_initial_size;
+ }
+ off_htab = htab_try_create (initial_size, off_hash, off_eq, NULL);
+ if (tracing)
+ htab_report (off_htab, "off_htab allocation");
+ if (off_htab == NULL)
+ dwz_oom ();
+ if (rd_multifile)
+ alt_off_htab = off_htab;
+ }
+
+ slot = htab_find_slot_with_hash (off_htab, die, off_hash (die), INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ assert (*slot == NULL);
+ *slot = die;
+}
+
+/* For DIE_OFFSET return dw_die_ref whose die_offset field is equal
+ to that value. Return NULL if no DIE is at that position (buggy
+ DWARF input?). */
+static dw_die_ref
+off_htab_lookup (dw_cu_ref cu, unsigned int die_offset)
+{
+ struct dw_die die;
+ die.die_offset = die_offset;
+ if (cu == NULL)
+ return (dw_die_ref) htab_find_with_hash (off_htab, &die, off_hash (&die));
+ if (unlikely (cu->cu_kind == CU_ALT))
+ return (dw_die_ref) htab_find_with_hash (alt_off_htab, &die,
+ off_hash (&die));
+ if (unlikely (cu->cu_kind == CU_TYPES))
+ return (dw_die_ref) htab_find_with_hash (types_off_htab, &die,
+ off_hash (&die));
+ return (dw_die_ref) htab_find_with_hash (off_htab, &die, off_hash (&die));
+}
+
+/* For a die attribute ATTR starting at PTR, with the die in CU, return the
+ pointer after the attribute. */
+static inline unsigned char * FORCE_INLINE
+skip_attr (unsigned int cu_version, struct abbrev_attr *attr,
+ unsigned char *ptr)
+{
+ uint32_t form = attr->form;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+ return skip_attr_no_dw_form_indirect (cu_version, form, ptr);
+}
+
+/* Return a pointer at which DIE's attribute AT is encoded, and fill in
+ its form into *FORMP. Return NULL if the attribute is not present. */
+static unsigned char *
+get_AT (dw_die_ref die, enum dwarf_attribute at, enum dwarf_form *formp)
+{
+ struct abbrev_tag *t = die->die_abbrev;
+ unsigned int i;
+ unsigned char *ptr;
+ dw_cu_ref cu = die_cu (die);
+ if (unlikely (fi_multifile) && cu->cu_kind == CU_ALT)
+ ptr = alt_data[DEBUG_INFO];
+ else if (cu->cu_kind == CU_TYPES)
+ ptr = debug_sections[DEBUG_TYPES].data;
+ else
+ ptr = debug_sections[DEBUG_INFO].data;
+ ptr += die->die_offset;
+ skip_leb128 (ptr);
+ for (i = 0; i < t->nattr; ++i)
+ {
+ uint32_t form = t->attr[i].form;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+ if (t->attr[i].attr == at)
+ {
+ *formp = form;
+ if (form == DW_FORM_implicit_const)
+ return (unsigned char *) &t->values[i];
+ return ptr;
+ }
+
+ ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+ }
+ return NULL;
+}
+
+/* Return an integer attribute AT of DIE. Set *PRESENT to true
+ if found. */
+static uint64_t
+get_AT_int (dw_die_ref die, enum dwarf_attribute at, bool *present,
+ enum dwarf_form *formp)
+{
+ unsigned char *ptr;
+ ptr = get_AT (die, at, formp);
+ *present = false;
+ if (ptr == NULL)
+ return 0;
+ *present = true;
+ switch (*formp)
+ {
+ case DW_FORM_ref_addr:
+ return read_size (ptr, die_cu (die)->cu_version == 2 ? ptr_size : 4);
+ case DW_FORM_addr:
+ return read_size (ptr, ptr_size);
+ case DW_FORM_flag_present:
+ return 1;
+ case DW_FORM_ref1:
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ return read_8 (ptr);
+ case DW_FORM_ref2:
+ case DW_FORM_data2:
+ return read_16 (ptr);
+ case DW_FORM_ref4:
+ case DW_FORM_data4:
+ case DW_FORM_sec_offset:
+ return read_32 (ptr);
+ case DW_FORM_ref8:
+ case DW_FORM_data8:
+ case DW_FORM_ref_sig8:
+ return read_64 (ptr);
+ case DW_FORM_sdata:
+ return read_sleb128 (ptr);
+ case DW_FORM_ref_udata:
+ case DW_FORM_udata:
+ return read_uleb128 (ptr);
+ case DW_FORM_implicit_const:
+ return *(uint64_t *)ptr; /* See get_AT. */
+ default:
+ *present = false;
+ return 0;
+ }
+}
+
+/* Return a pointer to string attribute AT in DIE, or NULL
+ if the attribute is not present. */
+static char *
+get_AT_string (dw_die_ref die, enum dwarf_attribute at)
+{
+ enum dwarf_form form;
+ unsigned char *ptr;
+ ptr = get_AT (die, at, &form);
+ if (ptr == NULL)
+ return NULL;
+ switch (form)
+ {
+ case DW_FORM_string:
+ return (char *) ptr;
+ case DW_FORM_strp:
+ {
+ unsigned int strp = read_32 (ptr);
+ if (unlikely (fi_multifile) && die_cu (die)->cu_kind == CU_ALT)
+ {
+ if (strp >= alt_size[DEBUG_STR])
+ return NULL;
+ return (char *) alt_data[DEBUG_STR] + strp;
+ }
+ if (strp >= debug_sections[DEBUG_STR].size)
+ return NULL;
+ return (char *) debug_sections[DEBUG_STR].data + strp;
+ }
+ case DW_FORM_line_strp:
+ {
+ unsigned int line_strp = read_32 (ptr);
+ if (line_strp >= debug_sections[DEBUG_LINE_STR].size)
+ return NULL;
+ else
+ return (char *) debug_sections[DEBUG_LINE_STR].data + line_strp;
+ }
+ default:
+ return NULL;
+ }
+}
+
+/* Parse DWARF expression referenced or stored in DIE, starting at
+ PTR with LEN bytes. Return non-zero on error. If NEED_ADJUST
+ is non-NULL, set *NEED_ADJUST to true if it contains DIE references
+ that will need adjusting. Some opcodes cause DIE or referenced
+ DIEs as unsuitable for moving into partial units, or limit their
+ location. */
+static int
+read_exprloc (DSO *dso, dw_die_ref die, unsigned char *ptr, size_t len,
+ bool *need_adjust)
+{
+ unsigned char *end = ptr + len;
+ unsigned char op;
+ GElf_Addr addr;
+ dw_die_ref ref;
+ dw_cu_ref cu;
+
+ while (ptr < end)
+ {
+ op = *ptr++;
+ switch (op)
+ {
+ case DW_OP_addr:
+ die->die_no_multifile = 1;
+ ptr += ptr_size;
+ break;
+ case DW_OP_deref:
+ case DW_OP_dup:
+ case DW_OP_drop:
+ case DW_OP_over:
+ case DW_OP_swap:
+ case DW_OP_rot:
+ case DW_OP_xderef:
+ case DW_OP_abs:
+ case DW_OP_and:
+ case DW_OP_div:
+ case DW_OP_minus:
+ case DW_OP_mod:
+ case DW_OP_mul:
+ case DW_OP_neg:
+ case DW_OP_not:
+ case DW_OP_or:
+ case DW_OP_plus:
+ case DW_OP_shl:
+ case DW_OP_shr:
+ case DW_OP_shra:
+ case DW_OP_xor:
+ case DW_OP_eq:
+ case DW_OP_ge:
+ case DW_OP_gt:
+ case DW_OP_le:
+ case DW_OP_lt:
+ case DW_OP_ne:
+ case DW_OP_lit0 ... DW_OP_lit31:
+ case DW_OP_reg0 ... DW_OP_reg31:
+ case DW_OP_nop:
+ case DW_OP_push_object_address:
+ case DW_OP_form_tls_address:
+ case DW_OP_call_frame_cfa:
+ case DW_OP_stack_value:
+ case DW_OP_GNU_push_tls_address:
+ case DW_OP_GNU_uninit:
+ break;
+ case DW_OP_const1u:
+ case DW_OP_pick:
+ case DW_OP_deref_size:
+ case DW_OP_xderef_size:
+ case DW_OP_const1s:
+ ++ptr;
+ break;
+ case DW_OP_const2u:
+ case DW_OP_const2s:
+ case DW_OP_skip:
+ case DW_OP_bra:
+ ptr += 2;
+ break;
+ case DW_OP_call2:
+ case DW_OP_call4:
+ case DW_OP_GNU_parameter_ref:
+ if (op == DW_OP_call2)
+ addr = read_16 (ptr);
+ else
+ addr = read_32 (ptr);
+ cu = die_cu (die);
+ ref = off_htab_lookup (cu, cu->cu_offset + addr);
+ if (ref == NULL)
+ {
+ error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+ "referenced by %s from DIE at [%x]",
+ dso->filename, cu->cu_offset + addr,
+ get_DW_OP_str (op), die->die_offset);
+ return 1;
+ }
+ if (op == DW_OP_call2)
+ ref->die_op_call2_referenced = 1;
+ if (ref->die_ck_state == CK_KNOWN)
+ {
+ dw_die_ref d;
+ ref->die_ck_state = CK_BAD;
+
+ d = ref;
+ while (!d->die_root
+ && d->die_parent->die_ck_state == CK_KNOWN)
+ {
+ d = d->die_parent;
+ d->die_ck_state = CK_BAD;
+ }
+ }
+ else
+ ref->die_ck_state = CK_BAD;
+ if (unlikely (low_mem))
+ {
+ ref->die_referenced = 1;
+ /* As .debug_loc adjustment is done after
+ write_info finishes, we need to keep the referenced
+ DIEs around uncollapsed. */
+ if (need_adjust)
+ ref->die_intercu_referenced = 1;
+ }
+ die->die_ck_state = CK_BAD;
+ if (need_adjust)
+ *need_adjust = true;
+ break;
+ case DW_OP_const4u:
+ case DW_OP_const4s:
+ ptr += 4;
+ break;
+ case DW_OP_call_ref:
+ case DW_OP_GNU_implicit_pointer:
+ case DW_OP_implicit_pointer:
+ case DW_OP_GNU_variable_value:
+ cu = die_cu (die);
+ addr = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+ if (cu->cu_version == 2)
+ ptr += ptr_size;
+ else
+ ptr += 4;
+ ref = off_htab_lookup (NULL, addr);
+ if (ref == NULL || (unlikely (low_mem) && ref->die_tag == 0))
+ {
+ error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+ "referenced by %s from DIE at [%x]",
+ dso->filename, addr, get_DW_OP_str (op), die->die_offset);
+ return 1;
+ }
+ ref->die_no_multifile = 1;
+ if (unlikely (low_mem))
+ {
+ ref->die_referenced = 1;
+ /* As .debug_loc adjustment is done after
+ write_info finishes, we need to keep the referenced
+ DIEs around uncollapsed. */
+ if (die_cu (ref) != cu || need_adjust)
+ ref->die_intercu_referenced = 1;
+ }
+ die->die_ck_state = CK_BAD;
+ if (need_adjust)
+ *need_adjust = true;
+ if (op == DW_OP_GNU_implicit_pointer || op == DW_OP_implicit_pointer)
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_const8u:
+ case DW_OP_const8s:
+ ptr += 8;
+ break;
+ case DW_OP_constu:
+ case DW_OP_plus_uconst:
+ case DW_OP_regx:
+ case DW_OP_piece:
+ case DW_OP_consts:
+ case DW_OP_breg0 ... DW_OP_breg31:
+ case DW_OP_fbreg:
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_bregx:
+ case DW_OP_bit_piece:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_implicit_value:
+ {
+ uint32_t leni = read_uleb128 (ptr);
+ ptr += leni;
+ }
+ break;
+ case DW_OP_GNU_entry_value:
+ case DW_OP_entry_value:
+ {
+ uint32_t leni = read_uleb128 (ptr);
+ if ((uint64_t) (end - ptr) < leni)
+ {
+ error (0, 0, "%s: %s with too large length",
+ get_DW_OP_str (op), dso->filename);
+ return 1;
+ }
+ if (read_exprloc (dso, die, ptr, leni, need_adjust))
+ return 1;
+ ptr += leni;
+ }
+ break;
+ case DW_OP_GNU_convert:
+ case DW_OP_convert:
+ case DW_OP_GNU_reinterpret:
+ case DW_OP_reinterpret:
+ addr = read_uleb128 (ptr);
+ if (addr == 0)
+ break;
+ goto typed_dwarf;
+ case DW_OP_GNU_regval_type:
+ case DW_OP_regval_type:
+ skip_leb128 (ptr);
+ addr = read_uleb128 (ptr);
+ goto typed_dwarf;
+ case DW_OP_GNU_const_type:
+ case DW_OP_const_type:
+ addr = read_uleb128 (ptr);
+ ptr += *ptr + 1;
+ goto typed_dwarf;
+ case DW_OP_GNU_deref_type:
+ case DW_OP_deref_type:
+ ++ptr;
+ addr = read_uleb128 (ptr);
+ typed_dwarf:
+ cu = die_cu (die);
+ ref = off_htab_lookup (cu, cu->cu_offset + addr);
+ if (ref == NULL)
+ {
+ error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+ "referenced by %s from DIE at [%x]",
+ dso->filename, cu->cu_offset + addr,
+ get_DW_OP_str (op), die->die_offset);
+ return 1;
+ }
+ if (unlikely (low_mem))
+ {
+ ref->die_referenced = 1;
+ /* As .debug_loc adjustment is done after
+ write_info finishes, we need to keep the referenced
+ DIEs around uncollapsed. */
+ if (need_adjust)
+ ref->die_intercu_referenced = 1;
+ }
+ ref->die_op_type_referenced = 1;
+ die->die_ck_state = CK_BAD;
+ if (need_adjust)
+ *need_adjust = true;
+ break;
+ default:
+ error (0, 0, "%s: Unknown DWARF %s "
+ "referenced from DIE at [%x]",
+ dso->filename, get_DW_OP_str (op),
+ die->die_offset);
+ return 1;
+ }
+ }
+ if (die->die_ck_state != CK_BAD)
+ die->u.p1.die_hash = iterative_hash (end - len, len, die->u.p1.die_hash);
+ return 0;
+}
+
+/* Add dummy die in CU at OFFSET. */
+static inline void FORCE_INLINE
+add_dummy_die (dw_cu_ref cu, unsigned int offset)
+{
+ dw_die_ref ref;
+ struct dw_die ref_buf;
+ void **slot;
+
+ memset (&ref_buf, '\0', offsetof (struct dw_die, die_child));
+ ref_buf.die_offset = offset;
+ ref_buf.die_collapsed_child = 1;
+ ref_buf.die_referenced = 1;
+ ref_buf.die_intercu_referenced = 1;
+ if (off_htab == NULL)
+ {
+ ref = pool_alloc (dw_die, offsetof (struct dw_die, die_child));
+ memcpy (ref, &ref_buf, offsetof (struct dw_die, die_child));
+ off_htab_add_die (cu, ref, NULL);
+ return;
+ }
+
+ slot
+ = htab_find_slot_with_hash (off_htab, &ref_buf, off_hash (&ref_buf),
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot != NULL)
+ return;
+
+ ref = pool_alloc (dw_die, offsetof (struct dw_die, die_child));
+ memcpy (ref, &ref_buf, offsetof (struct dw_die, die_child));
+ *slot = (void *) ref;
+}
+
+/* Add dummy DIEs for expr_loc at PTR. */
+static int
+read_exprloc_low_mem_phase1 (DSO *dso, dw_die_ref die, unsigned char *ptr,
+ size_t len)
+{
+ unsigned char *end = ptr + len;
+ unsigned char op;
+ GElf_Addr addr;
+ dw_cu_ref cu;
+
+ while (ptr < end)
+ {
+ op = *ptr++;
+ switch (op)
+ {
+ case DW_OP_addr:
+ ptr += ptr_size;
+ break;
+ case DW_OP_deref:
+ case DW_OP_dup:
+ case DW_OP_drop:
+ case DW_OP_over:
+ case DW_OP_swap:
+ case DW_OP_rot:
+ case DW_OP_xderef:
+ case DW_OP_abs:
+ case DW_OP_and:
+ case DW_OP_div:
+ case DW_OP_minus:
+ case DW_OP_mod:
+ case DW_OP_mul:
+ case DW_OP_neg:
+ case DW_OP_not:
+ case DW_OP_or:
+ case DW_OP_plus:
+ case DW_OP_shl:
+ case DW_OP_shr:
+ case DW_OP_shra:
+ case DW_OP_xor:
+ case DW_OP_eq:
+ case DW_OP_ge:
+ case DW_OP_gt:
+ case DW_OP_le:
+ case DW_OP_lt:
+ case DW_OP_ne:
+ case DW_OP_lit0 ... DW_OP_lit31:
+ case DW_OP_reg0 ... DW_OP_reg31:
+ case DW_OP_nop:
+ case DW_OP_push_object_address:
+ case DW_OP_form_tls_address:
+ case DW_OP_call_frame_cfa:
+ case DW_OP_stack_value:
+ case DW_OP_GNU_push_tls_address:
+ case DW_OP_GNU_uninit:
+ break;
+ case DW_OP_const1u:
+ case DW_OP_pick:
+ case DW_OP_deref_size:
+ case DW_OP_xderef_size:
+ case DW_OP_const1s:
+ ++ptr;
+ break;
+ case DW_OP_const2u:
+ case DW_OP_const2s:
+ case DW_OP_skip:
+ case DW_OP_bra:
+ ptr += 2;
+ break;
+ case DW_OP_call2:
+ case DW_OP_call4:
+ case DW_OP_GNU_parameter_ref:
+ if (op == DW_OP_call2)
+ read_16 (ptr);
+ else
+ read_32 (ptr);
+ break;
+ case DW_OP_const4u:
+ case DW_OP_const4s:
+ ptr += 4;
+ break;
+ case DW_OP_call_ref:
+ case DW_OP_GNU_implicit_pointer:
+ case DW_OP_implicit_pointer:
+ case DW_OP_GNU_variable_value:
+ cu = die_cu (die);
+ addr = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+ if (cu->cu_version == 2)
+ ptr += ptr_size;
+ else
+ ptr += 4;
+ /* Adding a dummy DIE ref to mark an intercu reference is only
+ necessary if die_cu (ref) != cu, but we don't track cu's during
+ low-mem phase1. */
+ add_dummy_die (cu, addr);
+ if (op == DW_OP_GNU_implicit_pointer || op == DW_OP_implicit_pointer)
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_const8u:
+ case DW_OP_const8s:
+ ptr += 8;
+ break;
+ case DW_OP_constu:
+ case DW_OP_plus_uconst:
+ case DW_OP_regx:
+ case DW_OP_piece:
+ case DW_OP_consts:
+ case DW_OP_breg0 ... DW_OP_breg31:
+ case DW_OP_fbreg:
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_bregx:
+ case DW_OP_bit_piece:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_implicit_value:
+ {
+ uint32_t leni = read_uleb128 (ptr);
+ ptr += leni;
+ }
+ break;
+ case DW_OP_GNU_entry_value:
+ case DW_OP_entry_value:
+ {
+ uint32_t leni = read_uleb128 (ptr);
+ if ((uint64_t) (end - ptr) < leni)
+ {
+ error (0, 0, "%s: %s with too large length",
+ get_DW_OP_str (op), dso->filename);
+ return 1;
+ }
+ if (read_exprloc_low_mem_phase1 (dso, die, ptr, leni))
+ return 1;
+ ptr += leni;
+ }
+ break;
+ case DW_OP_GNU_convert:
+ case DW_OP_convert:
+ case DW_OP_GNU_reinterpret:
+ case DW_OP_reinterpret:
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_GNU_regval_type:
+ case DW_OP_regval_type:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_GNU_const_type:
+ case DW_OP_const_type:
+ read_uleb128 (ptr);
+ ptr += *ptr + 1;
+ break;
+ case DW_OP_GNU_deref_type:
+ case DW_OP_deref_type:
+ ++ptr;
+ skip_leb128 (ptr);
+ break;
+ default:
+ error (0, 0, "%s: Unknown DWARF %s "
+ "referenced from DIE at [%x]",
+ dso->filename, get_DW_OP_str (op),
+ die->die_offset);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/* Add dummy DIEs for loclist at OFFSET. */
+static int
+read_loclist_low_mem_phase1 (DSO *dso, dw_cu_ref cu, dw_die_ref die,
+ GElf_Addr offset)
+{
+ unsigned char *ptr, *endsec;
+ GElf_Addr low, high;
+ size_t len = 0;
+ int sec;
+
+ sec = cu->cu_version < 5 ? DEBUG_LOC : DEBUG_LOCLISTS;
+ ptr = debug_sections[sec].data;
+ if (ptr == NULL)
+ {
+ error (0, 0, "%s: loclistptr attribute, yet no %s section",
+ dso->filename, debug_sections[sec].name);
+ return 1;
+ }
+ if (offset >= debug_sections[sec].size)
+ {
+ error (0, 0,
+ "%s: loclistptr offset %Ld outside of %s section",
+ dso->filename, (long long) offset, debug_sections[sec].name);
+ return 1;
+ }
+ endsec = ptr + debug_sections[sec].size;
+ ptr += offset;
+again:
+ while (ptr < endsec)
+ {
+ if (sec == DEBUG_LOC)
+ {
+ low = read_size (ptr, ptr_size);
+ high = read_size (ptr + ptr_size, ptr_size);
+ ptr += 2 * ptr_size;
+ if (low == 0 && high == 0)
+ break;
+
+ if (low == ~ (GElf_Addr) 0 || (ptr_size == 4 && low == 0xffffffff))
+ continue;
+
+ len = read_16 (ptr);
+ }
+ else
+ {
+ uint8_t lle = *ptr++;
+ switch (lle)
+ {
+ case DW_LLE_end_of_list:
+ goto done;
+
+ case DW_LLE_base_addressx:
+ skip_leb128 (ptr);
+ goto again;
+
+ case DW_LLE_startx_endx:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_startx_length:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_offset_pair:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_default_location:
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_base_address:
+ ptr += ptr_size;
+ goto again;
+
+ case DW_LLE_start_end:
+ ptr += 2 * ptr_size;
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_start_length:
+ ptr += ptr_size;
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_GNU_view_pair:
+ if (cu->cu_version != 5)
+ error (0, 0,
+ "%s: DW_LLE_GNU_view_pair used with DWARF version %u",
+ dso->filename, cu->cu_version);
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ goto again;
+
+ default:
+ error (0, 0,
+ "%s: unhandled location list entry 0x%x in %s section",
+ dso->filename, lle, debug_sections[sec].name);
+ return 1;
+ }
+ }
+
+ if (unlikely (!(ptr + len <= endsec)))
+ {
+ error (0, 0,
+ "%s: locexpr length 0x%Lx exceeds %s section",
+ dso->filename, (long long) len, debug_sections[sec].name);
+ return 1;
+ }
+
+ if (len > 0)
+ if (read_exprloc_low_mem_phase1 (dso, die, ptr, len))
+ return 1;
+
+ ptr += len;
+ }
+
+done:
+ return 0;
+}
+
+/* Add dummy dies for loc_exprs and loc_lists referenced from DIE. */
+static int
+add_locexpr_dummy_dies (DSO *dso, dw_cu_ref cu, dw_die_ref die,
+ unsigned char *ptr, uint32_t form, unsigned int attr,
+ size_t len)
+{
+ if (form == DW_FORM_block1 && cu->cu_version < 4)
+ {
+ /* Old DWARF uses blocks instead of exprlocs. */
+ switch (attr)
+ {
+ case DW_AT_frame_base:
+ case DW_AT_location:
+ case DW_AT_data_member_location:
+ case DW_AT_vtable_elem_location:
+ case DW_AT_byte_size:
+ case DW_AT_bit_offset:
+ case DW_AT_bit_size:
+ case DW_AT_string_length:
+ case DW_AT_lower_bound:
+ case DW_AT_return_addr:
+ case DW_AT_bit_stride:
+ case DW_AT_upper_bound:
+ case DW_AT_count:
+ case DW_AT_segment:
+ case DW_AT_static_link:
+ case DW_AT_use_location:
+ case DW_AT_allocated:
+ case DW_AT_associated:
+ case DW_AT_data_location:
+ case DW_AT_byte_stride:
+ case DW_AT_rank:
+ case DW_AT_call_value:
+ case DW_AT_call_target:
+ case DW_AT_call_target_clobbered:
+ case DW_AT_call_data_location:
+ case DW_AT_call_data_value:
+ case DW_AT_GNU_call_site_value:
+ case DW_AT_GNU_call_site_data_value:
+ case DW_AT_GNU_call_site_target:
+ case DW_AT_GNU_call_site_target_clobbered:
+ if (read_exprloc_low_mem_phase1 (dso, die, ptr, len))
+ return 1;
+ default:
+ break;
+ }
+
+ return 0;
+ }
+
+ if (form == DW_FORM_exprloc)
+ return read_exprloc_low_mem_phase1 (dso, die, ptr, len);
+
+ switch (attr)
+ {
+ case DW_AT_location:
+ case DW_AT_string_length:
+ case DW_AT_return_addr:
+ case DW_AT_data_member_location:
+ case DW_AT_frame_base:
+ case DW_AT_segment:
+ case DW_AT_static_link:
+ case DW_AT_use_location:
+ case DW_AT_vtable_elem_location:
+ if ((cu->cu_version < 4 && form == DW_FORM_data4)
+ || form == DW_FORM_sec_offset)
+ {
+ if (read_loclist_low_mem_phase1 (dso, cu, die, do_read_32 (ptr)))
+ return 1;
+ break;
+ }
+ else if (cu->cu_version < 4 && form == DW_FORM_data8)
+ {
+ if (read_loclist_low_mem_phase1 (dso, cu, die, do_read_64 (ptr)))
+ return 1;
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+/* Structure recording a portion of .debug_loc section that will need
+ adjusting. */
+struct debug_loc_adjust
+{
+ /* Starting offset in .debug_loc that needs adjusting. */
+ unsigned int start_offset;
+ /* End offset. This is used for hashing, as in theory some DIE
+ might be referencing a middle of a .debug_loc sequence (the address
+ part of it) referenced by a different DIE. */
+ unsigned int end_offset;
+ /* Owning CU. We give up if the same .debug_loc part that needs adjusting
+ is owned by more than one CU. */
+ dw_cu_ref cu;
+};
+ALIGN_STRUCT (debug_loc_adjust)
+
+/* Hash table and obstack for recording .debug_loc and .debug_loclists
+ adjustment ranges. */
+static htab_t loc_htab;
+static htab_t loclists_htab;
+
+/* Hash function for loc[lists]_htab. */
+static hashval_t
+loc_hash (const void *p)
+{
+ struct debug_loc_adjust *a = (struct debug_loc_adjust *)p;
+
+ return a->end_offset;
+}
+
+/* Equality function for loc[lists]_htab. */
+static int
+loc_eq (const void *p, const void *q)
+{
+ struct debug_loc_adjust *t1 = (struct debug_loc_adjust *)p;
+ struct debug_loc_adjust *t2 = (struct debug_loc_adjust *)q;
+
+ return t1->end_offset == t2->end_offset;
+}
+
+/* Parse .debug_loc portion starting at OFFSET, referenced by
+ DIE. Call read_exprloc on each of the DWARF expressions
+ contained in it. */
+static int
+read_loclist (DSO *dso, dw_cu_ref cu, dw_die_ref die, GElf_Addr offset)
+{
+ unsigned char *ptr, *endsec;
+ GElf_Addr low, high;
+ size_t len;
+ int sec;
+ bool need_adjust = false;
+
+ die->die_ck_state = CK_BAD;
+ sec = cu->cu_version < 5 ? DEBUG_LOC : DEBUG_LOCLISTS;
+ ptr = debug_sections[sec].data;
+ if (ptr == NULL)
+ {
+ error (0, 0, "%s: loclistptr attribute, yet no %s section",
+ dso->filename, debug_sections[sec].name);
+ return 1;
+ }
+ if (offset >= debug_sections[sec].size)
+ {
+ error (0, 0,
+ "%s: loclistptr offset %Ld outside of %s section",
+ dso->filename, (long long) offset, debug_sections[sec].name);
+ return 1;
+ }
+ endsec = ptr + debug_sections[sec].size;
+ ptr += offset;
+again:
+ while (ptr < endsec)
+ {
+ if (cu->cu_version < 5)
+ {
+ low = read_size (ptr, ptr_size);
+ high = read_size (ptr + ptr_size, ptr_size);
+ ptr += 2 * ptr_size;
+ if (low == 0 && high == 0)
+ break;
+
+ if (low == ~ (GElf_Addr) 0 || (ptr_size == 4 && low == 0xffffffff))
+ continue;
+
+ len = read_16 (ptr);
+ }
+ else
+ {
+ uint8_t lle = *ptr++;
+ switch (lle)
+ {
+ case DW_LLE_end_of_list:
+ goto done;
+
+ case DW_LLE_base_addressx:
+ skip_leb128 (ptr);
+ goto again;
+
+ case DW_LLE_startx_endx:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_startx_length:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_offset_pair:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_default_location:
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_base_address:
+ ptr += ptr_size;
+ goto again;
+
+ case DW_LLE_start_end:
+ ptr += 2 * ptr_size;
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_start_length:
+ ptr += ptr_size;
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_GNU_view_pair:
+ if (cu->cu_version != 5)
+ error (0, 0,
+ "%s: DW_LLE_GNU_view_pair used with DWARF version %u",
+ dso->filename, cu->cu_version);
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ goto again;
+
+ default:
+ error (0, 0,
+ "%s: unhandled location list entry 0x%x in %s section",
+ dso->filename, lle, debug_sections[sec].name);
+ return 1;
+ }
+ }
+
+ if (unlikely (!(ptr + len <= endsec)))
+ {
+ error (0, 0,
+ "%s: locexpr length 0x%Lx exceeds %s section",
+ dso->filename, (long long) len, debug_sections[sec].name);
+ return 1;
+ }
+
+ if (read_exprloc (dso, die, ptr, len, &need_adjust))
+ return 1;
+
+ ptr += len;
+ }
+
+done:
+ if (need_adjust)
+ {
+ struct debug_loc_adjust adj, *a;
+ void **slot;
+
+ adj.start_offset = offset;
+ adj.end_offset = ptr - debug_sections[sec].data;
+ adj.cu = cu;
+ if (sec == DEBUG_LOC)
+ {
+ if (loc_htab == NULL)
+ {
+ loc_htab = htab_try_create (50, loc_hash, loc_eq, NULL);
+ if (loc_htab == NULL)
+ dwz_oom ();
+ }
+ slot = htab_find_slot_with_hash (loc_htab, &adj, adj.end_offset,
+ INSERT);
+ }
+ else
+ {
+ if (loclists_htab == NULL)
+ {
+ loclists_htab = htab_try_create (50, loc_hash, loc_eq, NULL);
+ if (loclists_htab == NULL)
+ dwz_oom ();
+ }
+ slot = htab_find_slot_with_hash (loclists_htab, &adj, adj.end_offset,
+ INSERT);
+ }
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot == NULL)
+ {
+ a = pool_alloc (debug_loc_adjust, sizeof (*a));
+ *a = adj;
+ *slot = (void *) a;
+ }
+ else if (((struct debug_loc_adjust *)*slot)->cu != adj.cu)
+ {
+ error (0, 0, "%s: can't adjust %s section because multiple "
+ "CUs refer to it", dso->filename, debug_sections[sec].name);
+ return 1;
+ }
+ else if (((struct debug_loc_adjust *)*slot)->start_offset > offset)
+ ((struct debug_loc_adjust *)*slot)->start_offset = offset;
+ }
+
+ return 0;
+}
+
+/* Initialize die_odr_state field for DIE with CU. */
+static void
+set_die_odr_state (dw_cu_ref cu, dw_die_ref die)
+{
+ unsigned char *ptr;
+ struct abbrev_tag *t;
+ unsigned int i;
+ bool decl_p;
+ bool name_p;
+ bool other_p;
+
+ assert (die->die_odr_state == ODR_UNKNOWN);
+ die->die_odr_state = ODR_NONE;
+
+ if (low_mem)
+ /* Todo: allow low-mem mode. */
+ return;
+
+ if (multifile_mode == 0)
+ /* We're in regular mode, enable the ODR optimization. */
+ ;
+ else
+ /* One definition rule does not hold across executables and shared
+ libraries, so disable. */
+ return;
+
+ if (!die->die_toplevel)
+ /* A nested struct is not uniquely identified by its name. There may be a
+ different type with the same name nested in a different struct. */
+ return;
+
+ switch (cu->lang)
+ {
+ case DW_LANG_C_plus_plus:
+ case DW_LANG_C_plus_plus_03:
+ case DW_LANG_C_plus_plus_11:
+ case DW_LANG_C_plus_plus_14:
+ /* c++ defines one-definition-rule. */
+ if (die->die_tag == DW_TAG_structure_type
+ || die->die_tag == DW_TAG_class_type
+ || die->die_tag == DW_TAG_union_type)
+ /* ODR holds for all types, but we limit the optimization to these
+ tags, which are the ones likely to profit from it. */
+ ;
+ else
+ return;
+ break;
+ default:
+ return;
+ }
+
+ ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+ skip_leb128 (ptr);
+
+ t = die->die_abbrev;
+
+ decl_p = false;
+ name_p = false;
+ other_p = false;
+ for (i = 0; i < t->nattr; ++i)
+ {
+ if (t->attr[i].attr == DW_AT_name)
+ {
+ name_p = true;
+ continue;
+ }
+
+ if (t->attr[i].attr == DW_AT_declaration)
+ {
+ decl_p = true;
+ continue;
+ }
+
+ other_p = true;
+ }
+
+ if (!name_p)
+ /* Ignore anonymous types. */
+ return;
+
+ odr_active_p = true;
+
+ if (decl_p && !other_p && die->die_child == NULL)
+ {
+ /* Detected a declaration with no attributes other than DW_AT_name and
+ DW_AT_declaration, and no children. */
+ die->die_odr_state = ODR_DECL;
+ return;
+ }
+
+ die->die_odr_state = ODR_DEF;
+}
+
+/* Return the initialized die_odr_state field for DIE with CU. */
+static unsigned int
+die_odr_state (dw_die_ref die)
+{
+ assert (die->die_odr_state != ODR_UNKNOWN);
+ return die->die_odr_state;
+}
+
+/* This function computes u.p1.die_hash and die_ck_state of DIE.
+ The field u.p1.die_hash is an iterative hash of:
+ - the die_tag,
+ - for all attributes except DW_AT_sibling: the attribute code,
+ - for non-reference class attributes: the value of the attribute (magic
+ for DW_AT_*_file),
+ - for DW_FORM_ref_addr attributes: the value of the attribute,
+ - for reference class attributes that point into the subtree of TOP_DIE
+ (note, other references are intentionally ignored here):
+ ref->u.p1.die_enter - top_die->u.p1.die_enter,
+ - for all children: their hashes.
+ The field die_ck_state is set to CK_BAD if the die is unsuitable for
+ moving into a partial unit (contains code references or other reasons).
+ TOP_DIE is initially NULL when DW_TAG_*_unit or die_named_namespace dies
+ are walked. */
+static int
+checksum_die (DSO *dso, dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die)
+{
+ unsigned short s;
+ struct abbrev_tag *t;
+ unsigned int i;
+ unsigned char *ptr;
+ dw_die_ref child;
+ bool only_hash_name_p;
+ hashval_t die_hash2;
+
+ switch (die->die_ck_state)
+ {
+ case CK_UNKNOWN:
+ break;
+ case CK_KNOWN:
+ case CK_BAD:
+ return 0;
+ case CK_BEING_COMPUTED:
+ die->die_ck_state = CK_BAD;
+ return 0;
+ }
+ die->die_ck_state = CK_BEING_COMPUTED;
+ die->u.p1.die_hash = 0;
+ if (die->die_tag == DW_TAG_compile_unit
+ || die->die_tag == DW_TAG_partial_unit
+ || die->die_tag == DW_TAG_namespace
+ || die->die_tag == DW_TAG_module
+ || die->die_tag == DW_TAG_imported_unit)
+ die->die_ck_state = CK_BAD;
+ t = die->die_abbrev;
+ ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+ skip_leb128 (ptr);
+ s = die->die_tag;
+ die->u.p1.die_hash = iterative_hash_object (s, die->u.p1.die_hash);
+ if (dump_checksum_p)
+ fprintf (stderr, "DIE %x, hash: %x, tag\n", die->die_offset,
+ die->u.p1.die_hash);
+ if (uni_lang_p && die == top_die)
+ {
+ die->u.p1.die_hash
+ = iterative_hash_object (cu->lang, die->u.p1.die_hash);
+ if (dump_checksum_p)
+ fprintf (stderr, "DIE %x, hash: %x, lang\n", die->die_offset,
+ die->u.p1.die_hash);
+ }
+
+ if (odr && die->die_odr_state == ODR_UNKNOWN)
+ set_die_odr_state (die_cu (die), die);
+ only_hash_name_p = odr && die_odr_state (die) != ODR_NONE;
+ die_hash2 = 0;
+ if (only_hash_name_p)
+ die_hash2 = die->u.p1.die_hash;
+ for (i = 0; i < t->nattr; ++i)
+ {
+ uint32_t form = t->attr[i].form;
+ size_t len = 0;
+ unsigned char *old_ptr;
+ bool handled = false;
+ int64_t svalue;
+ uint64_t value;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+ old_ptr = ptr;
+
+ switch (t->attr[i].attr)
+ {
+ /* Ignore DW_AT_sibling attribute. */
+ case DW_AT_sibling:
+ handled = true;
+ break;
+ /* These attributes reference code, prevent moving
+ DIEs with them. */
+ case DW_AT_low_pc:
+ case DW_AT_high_pc:
+ case DW_AT_entry_pc:
+ case DW_AT_ranges:
+ case DW_AT_call_return_pc:
+ case DW_AT_call_pc:
+ die->die_ck_state = CK_BAD;
+ break;
+ case DW_AT_start_scope:
+ if (form == DW_FORM_sec_offset)
+ die->die_ck_state = CK_BAD;
+ break;
+ /* These attributes reference other sections, they
+ can't be moved to other files easily. */
+ case DW_AT_stmt_list:
+ case DW_AT_macro_info:
+ case DW_AT_macros:
+ case DW_AT_GNU_macros:
+ if (!die->die_root)
+ die->die_no_multifile = 1;
+ break;
+ /* loclistptr attributes. */
+ case DW_AT_location:
+ case DW_AT_string_length:
+ case DW_AT_return_addr:
+ case DW_AT_data_member_location:
+ case DW_AT_frame_base:
+ case DW_AT_segment:
+ case DW_AT_static_link:
+ case DW_AT_use_location:
+ case DW_AT_vtable_elem_location:
+ if ((cu->cu_version < 4 && form == DW_FORM_data4)
+ || form == DW_FORM_sec_offset)
+ {
+ if (read_loclist (dso, cu, die, read_32 (ptr)))
+ return 1;
+ ptr = old_ptr;
+ break;
+ }
+ else if (cu->cu_version < 4 && form == DW_FORM_data8)
+ {
+ if (read_loclist (dso, cu, die, read_64 (ptr)))
+ return 1;
+ ptr = old_ptr;
+ break;
+ }
+ break;
+ case DW_AT_decl_file:
+ case DW_AT_call_file:
+ switch (form)
+ {
+ case DW_FORM_data1: value = read_8 (ptr); handled = true; break;
+ case DW_FORM_data2: value = read_16 (ptr); handled = true; break;
+ case DW_FORM_data4: value = read_32 (ptr); handled = true; break;
+ case DW_FORM_data8: value = read_64 (ptr); handled = true; break;
+ case DW_FORM_udata:
+ value = read_uleb128 (ptr); handled = true; break;
+ case DW_FORM_sdata:
+ {
+ svalue = read_sleb128 (ptr);
+ if (svalue >= 0)
+ {
+ value = svalue;
+ handled = true;
+ break;
+ }
+ else
+ {
+ negative:
+ error (0, 0, "%s: negative value %" PRId64 " for %s",
+ dso->filename, svalue,
+ get_DW_AT_str (t->attr[i].attr));
+ return 1;
+ }
+ }
+ case DW_FORM_implicit_const:
+ {
+ svalue = t->values[i];
+ if (svalue >= 0)
+ {
+ value = svalue;
+ handled = true;
+ break;
+ }
+ else
+ goto negative;
+ }
+ default:
+ error (0, 0, "%s: Unhandled %s for %s",
+ dso->filename, get_DW_FORM_str (form),
+ get_DW_AT_str (t->attr[i].attr));
+ return 1;
+ }
+ if (handled)
+ {
+ unsigned char *new_ptr = ptr;
+ ptr = old_ptr;
+ if (value > cu->cu_nfiles)
+ {
+ error (0, 0, "%s: Invalid %s file number %d",
+ dso->filename, get_DW_AT_str (t->attr[i].attr),
+ (int) value);
+ return 1;
+ }
+ if (value == 0)
+ handled = false;
+ else if (!ignore_locus && die->die_ck_state != CK_BAD)
+ {
+ struct dw_file *cu_file = &cu->cu_files[value - 1];
+ size_t file_len = strlen (cu_file->file);
+ s = t->attr[i].attr;
+ hash_init_state ();
+ hash_update_state_object (die->u.p1.die_hash);
+ hash_update_state_object (s);
+ hash_update_state_object (cu_file->time);
+ hash_update_state_object (cu_file->size);
+ hash_update_state (cu_file->file, file_len + 1);
+ if (cu_file->dir)
+ {
+ hash_update_state (cu_file->dir,
+ strlen (cu_file->dir) + 1);
+ }
+ /* Ignore DW_AT_comp_dir for DW_AT_*_file <built-in>
+ etc. if immediately followed by DW_AT_*_line 0. */
+ else if (cu_file->file_angle_brackets_encapsulated_no_slash
+ && i + 1 < t->nattr
+ && t->attr[i + 1].attr
+ == (t->attr[i].attr == DW_AT_decl_file
+ ? DW_AT_decl_line : DW_AT_call_line)
+ && t->attr[i + 1].form == DW_FORM_data1
+ && *new_ptr == 0)
+ {
+ die->u.p1.die_hash = hash_digest ();
+ break;
+ }
+
+ die->u.p1.die_hash = hash_digest ();
+
+ if (cu->cu_comp_dir
+ && (cu_file->dir ? cu_file->dir[0]
+ : cu_file->file[0]) != '/')
+ die->u.p1.die_hash
+ = iterative_hash (cu->cu_comp_dir,
+ strlen (cu->cu_comp_dir) + 1,
+ die->u.p1.die_hash);
+ }
+ }
+ break;
+ case DW_AT_decl_line:
+ case DW_AT_decl_column:
+ case DW_AT_call_line:
+ case DW_AT_call_column:
+ if (ignore_locus)
+ {
+ handled = true;
+ break;
+ }
+ switch (form)
+ {
+ case DW_FORM_data1: value = read_8 (ptr); handled = true; break;
+ case DW_FORM_data2: value = read_16 (ptr); handled = true; break;
+ case DW_FORM_data4: value = read_32 (ptr); handled = true; break;
+ case DW_FORM_data8: value = read_64 (ptr); handled = true; break;
+ case DW_FORM_udata:
+ value = read_uleb128 (ptr); handled = true; break;
+ case DW_FORM_sdata:
+ {
+ svalue = read_sleb128 (ptr);
+ if (svalue >= 0)
+ {
+ value = svalue;
+ handled = true;
+ break;
+ }
+ else
+ goto negative;
+ }
+ case DW_FORM_implicit_const:
+ svalue = t->values[i];
+ if (svalue >= 0)
+ {
+ value = svalue;
+ handled = true;
+ break;
+ }
+ else
+ goto negative;
+ default:
+ error (0, 0, "%s: Unhandled %s for %s",
+ dso->filename, get_DW_FORM_str (form),
+ get_DW_AT_str (t->attr[i].attr));
+ return 1;
+ }
+ if (handled)
+ {
+ ptr = old_ptr;
+ s = t->attr[i].attr;
+ die->u.p1.die_hash
+ = iterative_hash_object (s, die->u.p1.die_hash);
+ die->u.p1.die_hash
+ = iterative_hash_object (value, die->u.p1.die_hash);
+ }
+ break;
+ default:
+ break;
+ }
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ if (unlikely (op_multifile || rd_multifile || fi_multifile))
+ {
+ dw_die_ref ref;
+
+ value = read_size (ptr, cu->cu_version == 2
+ ? ptr_size : 4);
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ if (die->die_ck_state != CK_BAD)
+ {
+ s = t->attr[i].attr;
+ die->u.p1.die_hash
+ = iterative_hash_object (s, die->u.p1.die_hash);
+ }
+ ref = off_htab_lookup (cu, value);
+ if (ref == NULL)
+ {
+ error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+ "referenced by %s from DIE at [%x]",
+ dso->filename, value,
+ get_DW_AT_str (t->attr[i].attr), die->die_offset);
+ return 1;
+ }
+ if (unlikely (op_multifile) && ref->die_collapsed_child)
+ ref = ref->die_parent;
+ if (cu == die_cu (ref))
+ {
+ /* The reference was encoded using a section-relative
+ encoding, while if it could have been encoded using
+ CU-relative encoding. Typically, the latter is used,
+ because:
+ - it's potentially smaller, and
+ - it doesn't require a link-time relocation. */
+
+ /* Assert that the multifile only contains section-relative
+ encoding when necessary. */
+ assert (!op_multifile && !rd_multifile);
+
+ if (fi_multifile)
+ {
+ /* It's possible that the input DWARF contains this
+ sub-optimal reference. We currently don't optimize
+ this during single-file optimization, so it will still
+ be there during finalize_multifile. Bail out to handle
+ this conservatively. */
+ die->die_ck_state = CK_BAD;
+ return 0;
+ }
+ }
+ /* Assert that during op_multifile, die belongs to the same object
+ as ref. */
+ assert (!op_multifile || cu->cu_chunk == die_cu (ref)->cu_chunk);
+ handled = true;
+ break;
+ }
+ die->die_no_multifile = 1;
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_addr:
+ die->die_no_multifile = 1;
+ ptr += ptr_size;
+ break;
+ case DW_FORM_flag_present:
+ break;
+ case DW_FORM_implicit_const:
+ if (!handled && die->die_ck_state != CK_BAD)
+ {
+ handled = true;
+ s = t->attr[i].attr;
+ die->u.p1.die_hash
+ = iterative_hash_object (s, die->u.p1.die_hash);
+ die->u.p1.die_hash
+ = iterative_hash_object (t->values[i], die->u.p1.die_hash);
+ }
+ break;
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ ++ptr;
+ break;
+ case DW_FORM_data2:
+ ptr += 2;
+ break;
+ case DW_FORM_data4:
+ case DW_FORM_sec_offset:
+ ptr += 4;
+ break;
+ case DW_FORM_data8:
+ ptr += 8;
+ break;
+ case DW_FORM_data16:
+ ptr += 16;
+ break;
+ case DW_FORM_ref_sig8:
+ die->die_no_multifile = 1;
+ ptr += 8;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ skip_leb128 (ptr);
+ break;
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ switch (form)
+ {
+ case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+ case DW_FORM_ref1: value = read_8 (ptr); break;
+ case DW_FORM_ref2: value = read_16 (ptr); break;
+ case DW_FORM_ref4: value = read_32 (ptr); break;
+ case DW_FORM_ref8: value = read_64 (ptr); break;
+ default: abort ();
+ }
+ if (!handled)
+ {
+ dw_die_ref ref
+ = off_htab_lookup (cu, cu->cu_offset + value);
+ if (ref == NULL)
+ {
+ error (0, 0, "%s: Couldn't find DIE at [%" PRIx64 "] "
+ "referenced by %s from DIE at [%x]",
+ dso->filename, cu->cu_offset + value,
+ get_DW_AT_str (t->attr[i].attr), die->die_offset);
+ return 1;
+ }
+ if (die->die_ck_state != CK_BAD)
+ {
+ s = t->attr[i].attr;
+ die->u.p1.die_hash
+ = iterative_hash_object (s, die->u.p1.die_hash);
+ }
+ if (top_die
+ && !ref->die_collapsed_child
+ && ref->u.p1.die_enter >= top_die->u.p1.die_enter
+ && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+ {
+ if (die->die_ck_state != CK_BAD)
+ {
+ unsigned int val
+ = ref->u.p1.die_enter - top_die->u.p1.die_enter;
+ die->u.p1.die_hash
+ = iterative_hash_object (val, die->u.p1.die_hash);
+ }
+ }
+ handled = true;
+ }
+ break;
+ case DW_FORM_strp:
+ if (unlikely (op_multifile || rd_multifile || fi_multifile)
+ && die->die_ck_state != CK_BAD)
+ {
+ value = read_32 (ptr);
+ if (value >= debug_sections[DEBUG_STR].size)
+ die->die_ck_state = CK_BAD;
+ else
+ {
+ unsigned char *p = debug_sections[DEBUG_STR].data + value;
+ unsigned int l = strlen ((char *) p) + 1;
+ s = t->attr[i].attr;
+ die->u.p1.die_hash
+ = iterative_hash_object (s, die->u.p1.die_hash);
+ die->u.p1.die_hash
+ = iterative_hash (p, l, die->u.p1.die_hash);
+ handled = true;
+ }
+ }
+ else
+ {
+ ptr += 4;
+ if (only_hash_name_p && t->attr[i].attr == DW_AT_name)
+ {
+ s = t->attr[i].attr;
+ die_hash2 = iterative_hash_object (s, die_hash2);
+ die_hash2
+ = iterative_hash (old_ptr, ptr - old_ptr, die_hash2);
+ }
+ }
+ break;
+ case DW_FORM_line_strp:
+ /* There is no .debug_line_str in the alt file, so we cannot
+ move this DIE unless we change the string reference.
+ This is not that bad because DW_FORM_line_strp is often
+ only used in the CU DIE for file name and comp_dir and we
+ don't move the CU DIE anyway. */
+ die->die_ck_state = CK_BAD;
+ break;
+ case DW_FORM_string:
+ ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+ if (only_hash_name_p && t->attr[i].attr == DW_AT_name)
+ {
+ s = t->attr[i].attr;
+ die_hash2 = iterative_hash_object (s, die_hash2);
+ die_hash2
+ = iterative_hash (old_ptr, ptr - old_ptr, die_hash2);
+ }
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ case DW_FORM_block1:
+ len = *ptr++;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block:
+ len = read_uleb128 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_exprloc:
+ len = read_uleb128 (ptr);
+ break;
+ default:
+ abort ();
+ }
+
+ if (form == DW_FORM_block1 && cu->cu_version < 4)
+ {
+ /* Old DWARF uses blocks instead of exprlocs. */
+ switch (t->attr[i].attr)
+ {
+ case DW_AT_frame_base:
+ case DW_AT_location:
+ case DW_AT_data_member_location:
+ case DW_AT_vtable_elem_location:
+ case DW_AT_byte_size:
+ case DW_AT_bit_offset:
+ case DW_AT_bit_size:
+ case DW_AT_string_length:
+ case DW_AT_lower_bound:
+ case DW_AT_return_addr:
+ case DW_AT_bit_stride:
+ case DW_AT_upper_bound:
+ case DW_AT_count:
+ case DW_AT_segment:
+ case DW_AT_static_link:
+ case DW_AT_use_location:
+ case DW_AT_allocated:
+ case DW_AT_associated:
+ case DW_AT_data_location:
+ case DW_AT_byte_stride:
+ case DW_AT_rank:
+ case DW_AT_call_value:
+ case DW_AT_call_target:
+ case DW_AT_call_target_clobbered:
+ case DW_AT_call_data_location:
+ case DW_AT_call_data_value:
+ case DW_AT_GNU_call_site_value:
+ case DW_AT_GNU_call_site_data_value:
+ case DW_AT_GNU_call_site_target:
+ case DW_AT_GNU_call_site_target_clobbered:
+ if (die->die_ck_state != CK_BAD)
+ {
+ s = t->attr[i].attr;
+ die->u.p1.die_hash
+ = iterative_hash_object (s, die->u.p1.die_hash);
+ }
+ if (read_exprloc (dso, die, ptr, len, NULL))
+ return 1;
+ handled = true;
+ default:
+ break;
+ }
+ }
+ else if (form == DW_FORM_exprloc)
+ {
+ if (die->die_ck_state != CK_BAD)
+ {
+ s = t->attr[i].attr;
+ die->u.p1.die_hash
+ = iterative_hash_object (s, die->u.p1.die_hash);
+ }
+ if (read_exprloc (dso, die, ptr, len, NULL))
+ return 1;
+ handled = true;
+ }
+ ptr += len; /* Skip expr/blocks. */
+ if (!handled && die->die_ck_state != CK_BAD)
+ {
+ s = t->attr[i].attr;
+ die->u.p1.die_hash = iterative_hash_object (s, die->u.p1.die_hash);
+ die->u.p1.die_hash
+ = iterative_hash (old_ptr, ptr - old_ptr, die->u.p1.die_hash);
+ }
+
+ if (dump_checksum_p)
+ fprintf (stderr, "DIE %x, hash: %x, attr (%d)\n", die->die_offset,
+ die->u.p1.die_hash, i);
+ }
+
+ for (child = die->die_child, i = 0; child; child = child->die_sib, ++i)
+ if (checksum_die (dso, cu,
+ top_die ? top_die
+ : child->die_named_namespace
+ ? NULL : child, child))
+ return 1;
+ else if (die->die_ck_state != CK_BAD)
+ {
+ if (child->die_ck_state == CK_KNOWN)
+ {
+ die->u.p1.die_hash
+ = iterative_hash_object (child->u.p1.die_hash,
+ die->u.p1.die_hash);
+ if (dump_checksum_p)
+ fprintf (stderr, "DIE %x, hash: %x, child (%i)\n",
+ die->die_offset, die->u.p1.die_hash, i);
+ die->die_no_multifile
+ |= child->die_no_multifile;
+ }
+ else
+ die->die_ck_state = CK_BAD;
+ }
+ if (die->die_ck_state == CK_BEING_COMPUTED)
+ die->die_ck_state = CK_KNOWN;
+
+ if (dump_checksum_p)
+ fprintf (stderr, "DIE %x, hash: %x, final\n", die->die_offset,
+ die->u.p1.die_hash);
+
+ if (only_hash_name_p)
+ {
+ unsigned int tmp = die->u.p1.die_hash;
+ die->u.p1.die_hash = die_hash2;
+ die->u.p1.die_hash2 = tmp;
+ }
+
+ return 0;
+}
+
+/* Helper function for checksum_ref_die to sort DIE pointers
+ by increasing u.p1.die_hash. */
+static int
+checksum_ref_die_cmp (const void *p, const void *q)
+{
+ dw_die_ref die1 = *(dw_die_ref *)p;
+ dw_die_ref die2 = *(dw_die_ref *)q;
+ if (die1->u.p1.die_hash < die2->u.p1.die_hash)
+ return -1;
+ if (die1->u.p1.die_hash > die2->u.p1.die_hash)
+ return 1;
+ /* The rest is just to keep the sort stable. If there is more than
+ one DIE with the same hash, we don't consider any of them as suitable
+ starting point for the walk. */
+ if (die1->die_offset < die2->die_offset)
+ return -1;
+ if (die1->die_offset > die2->die_offset)
+ return 1;
+ return 0;
+}
+
+/* This function is the second phase of hash computation, which computes
+ u.p1.die_ref_hash after u.p1.die_hash has been computed.
+ u.p1.die_ref_hash is an iterative hash of the references (other than
+ those checksummed already into u.p1.die_hash by checksum_die).
+ u.p1.die_ref_hash is only computed for the toplevel DIEs, i.e. children
+ of DW_TAG_*_unit or die_named_namespace DIEs. So, in the graph
+ containing DIEs as nodes and parent<->child and referrer<->referree edges
+ we virtually coalesce all children of toplevel DIEs into the
+ corresponding toplevel DIE ultimate parent node. The function has 4
+ modes of operation:
+
+ The first one is when TOP_DIE, SECOND_IDX and SECOND_HASH are all NULL,
+ this is when we walk through DW_TAG_*_unit and die_named_namespace DIEs
+ to reach their children.
+
+ The second mode of operation is with TOP_DIE != NULL and both SECOND_IDX
+ and SECOND_HASH NULL. In this mode we optimistically assume there are no
+ cycles in the graph, first hash into TOP_DIE's u.p1.die_ref_hash its
+ u.p1.die_hash, push the TOP_DIE into a vector (in OB obstack), for each
+ reference if the referree isn't already toplevel DIE find its
+ (grand)*parent that is a toplevel DIE, recurse on that and if it computed
+ the referree toplevel DIE's u.p1.die_ref_hash (i.e. no cycle),
+ iteratively hash in the referree toplevel DIE's u.p1.die_ref_hash (and,
+ if referree isn't toplevel, before that also its relative position in the
+ subtree). When existing, remove the TOP_DIE from the vector and set
+ die_ref_hash_computed to note that it is computed and doesn't have to be
+ computed again. If there are no cycles, the return value of the function
+ is 0. If a cycle is found, things are more complicated. We can't just
+ not walk into DIEs we've already seen and compute u.p1.die_ref_hash for
+ toplevel DIEs on the cycle(s), because in different CUs matching cycles
+ might be starting computation of the hash from different nodes on the
+ cycle (the order of children of DW_TAG_*_unit or DW_TAG_namespace is
+ usually not significant in DWARF). So, if a cycle is found, the return
+ value is a minimum of the die_ref_seen indexes (positions in the
+ vector); at that point it makes no sense to further compute
+ u.p1.die_ref_hash of the toplevel DIEs on the cycle, but for references
+ to acyclic subgraphs we still continue computing their u.p1.die_ref_hash.
+ For DIEs on the cycle(s) pointers to them aren't immediately removed from
+ the vector and everything is handled only after reaching the TOP_DIE with
+ die_ref_seen equal to the minimum vector index (i.e. the first of
+ the DIEs on the cycle(s) we've seen). At this point in the vector
+ starting with that index should be a list of DIEs on the cycle, and all
+ references to (toplevel) DIEs not on that list from those DIEs should
+ have die_ref_hash_computed already set. If the cycle has matches in
+ different CUs, we should have the same set of u.p1.die_hash values in the
+ list in between all those CUs, but the order might be different. At this
+ point we try to find a DIE from which to start walk using third mode of
+ operation of this function. We can't base that decision on e.g.
+ die_offset, as it may be not just different between the CUs, but the
+ matching DIEs might be in different relative orders. So we look if there
+ is just a single DIE with lowest u.p1.die_hash value and use that in that
+ case, (and if not, look if there is just a single DIE with second lowest
+ u.p1.die_hash and so on up to 20th). If none is found, the more
+ expensive 4th mode of operation is used instead.
+
+ The third mode of operation is when TOP_DIE, SECOND_IDX and SECOND_HASH
+ are all non-NULL. This mode is used when the initial TOP_DIE is
+ a uniquely chosen DIE on the cycle (same in each CU that has
+ matching cycle). In this mode into each TOP_DIE's u.p1.die_ref_hash
+ we hash in *SECOND_IDX (counter when in that walk the DIE has been
+ seen first) and relative referree positions in subtree, and hash in
+ referree toplevel u.p1.die_ref_hash into *SECOND_HASH, and finally
+ when the walk finishes, the caller will compute the final
+ u.p1.die_ref_hash for DIEs on the cycle(s) from their intermediate
+ u.p1.die_ref_hash and *SECOND_HASH.
+
+ The last mode of operation is when TOP_DIE and SECOND_HASH
+ are non-NULL, but SECOND_IDX is NULL. This mode is used when no
+ suitable DIE from which to start walking the cycle has been discovered.
+ In that case we for each DIE on the cycle walk everything that hasn't
+ die_ref_hash_computed yet, for DIEs seen that have die_ref_hash_computed
+ hash in their u.p1.die_ref_hash, otherwise (DIEs on the current cycle(s))
+ hash in their u.p1.die_hash. */
+static unsigned int
+checksum_ref_die (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die,
+ unsigned int *second_idx, hashval_t *second_hash)
+{
+ struct abbrev_tag *t;
+ unsigned int i, ret = 0;
+ unsigned char *ptr;
+ dw_die_ref child;
+
+ if (top_die == die)
+ {
+ if (die->die_ref_hash_computed)
+ return 0;
+ if (die->die_ck_state != CK_KNOWN)
+ return 0;
+ if (die->die_ref_seen)
+ return second_hash != NULL ? 0 : die->die_ref_seen;
+ if (second_hash != NULL)
+ {
+ die->die_ref_seen = 1;
+ if (second_idx != NULL)
+ {
+ die->u.p1.die_ref_hash
+ = iterative_hash_object (*second_idx, die->u.p1.die_hash);
+ (*second_idx)++;
+ }
+ }
+ else
+ {
+ die->die_ref_seen
+ = obstack_object_size (&ob) / sizeof (void *) + 1;
+ obstack_ptr_grow (&ob, die);
+ die->u.p1.die_ref_hash = die->u.p1.die_hash;
+ }
+ }
+ else
+ assert (top_die == NULL || die->die_ck_state == CK_KNOWN);
+ t = die->die_abbrev;
+ for (i = 0; i < t->nattr; ++i)
+ if (t->attr[i].attr != DW_AT_sibling)
+ switch (t->attr[i].form)
+ {
+ case DW_FORM_ref_addr:
+ if (unlikely (op_multifile || rd_multifile || fi_multifile))
+ i = -2U;
+ break;
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_indirect:
+ i = -2U;
+ break;
+ }
+ if (i == -1U)
+ {
+ ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+ skip_leb128 (ptr);
+ for (i = 0; i < t->nattr; ++i)
+ {
+ uint32_t form = t->attr[i].form;
+ size_t len = 0;
+ uint64_t value;
+ dw_die_ref ref, reft;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ if (unlikely (op_multifile || rd_multifile || fi_multifile))
+ {
+ value = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ assert (t->attr[i].attr != DW_AT_sibling);
+ if (top_die == NULL)
+ break;
+ ref = off_htab_lookup (cu, value);
+ goto finish_ref;
+ }
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_addr:
+ ptr += ptr_size;
+ break;
+ case DW_FORM_flag_present:
+ case DW_FORM_implicit_const:
+ break;
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ ++ptr;
+ break;
+ case DW_FORM_data2:
+ ptr += 2;
+ break;
+ case DW_FORM_data4:
+ case DW_FORM_sec_offset:
+ case DW_FORM_strp:
+ case DW_FORM_line_strp:
+ ptr += 4;
+ break;
+ case DW_FORM_data8:
+ case DW_FORM_ref_sig8:
+ ptr += 8;
+ break;
+ case DW_FORM_data16:
+ ptr += 16;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ skip_leb128 (ptr);
+ break;
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ switch (form)
+ {
+ case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+ case DW_FORM_ref1: value = read_8 (ptr); break;
+ case DW_FORM_ref2: value = read_16 (ptr); break;
+ case DW_FORM_ref4: value = read_32 (ptr); break;
+ case DW_FORM_ref8: value = read_64 (ptr); break;
+ default: abort ();
+ }
+ if (t->attr[i].attr == DW_AT_sibling || top_die == NULL)
+ break;
+ ref = off_htab_lookup (cu, cu->cu_offset + value);
+ if (ref->u.p1.die_enter >= top_die->u.p1.die_enter
+ && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+ break;
+ finish_ref:
+ reft = ref;
+ while (!reft->die_root
+ && reft->die_parent->die_tag != DW_TAG_compile_unit
+ && reft->die_parent->die_tag != DW_TAG_partial_unit
+ && !reft->die_parent->die_named_namespace)
+ reft = reft->die_parent;
+ if (reft->die_ck_state != CK_KNOWN || reft->die_root)
+ top_die->die_ck_state = CK_BAD;
+ else
+ {
+ unsigned int r = checksum_ref_die (die_cu (reft), reft, reft,
+ second_idx, second_hash);
+ if (ret == 0 || (r && r < ret))
+ ret = r;
+ if (reft->die_ck_state != CK_KNOWN)
+ top_die->die_ck_state = CK_BAD;
+ else
+ top_die->die_no_multifile |= reft->die_no_multifile;
+ }
+ if (top_die->die_ck_state == CK_BAD)
+ {
+ if (top_die != die)
+ return ret;
+ i = t->nattr - 1;
+ break;
+ }
+ if (ret)
+ break;
+ if (reft != ref)
+ {
+ unsigned int val
+ = ref->u.p1.die_enter - reft->u.p1.die_enter;
+ if (second_hash != NULL && second_idx == NULL)
+ *second_hash
+ = iterative_hash_object (val, *second_hash);
+ else
+ top_die->u.p1.die_ref_hash
+ = iterative_hash_object (val,
+ top_die->u.p1.die_ref_hash);
+ }
+ if (second_hash)
+ {
+ if (second_idx == NULL && !reft->die_ref_hash_computed)
+ *second_hash
+ = iterative_hash_object (reft->u.p1.die_hash,
+ *second_hash);
+ else
+ *second_hash
+ = iterative_hash_object (reft->u.p1.die_ref_hash,
+ *second_hash);
+ }
+ else
+ top_die->u.p1.die_ref_hash
+ = iterative_hash_object (reft->u.p1.die_ref_hash,
+ top_die->u.p1.die_ref_hash);
+ break;
+ case DW_FORM_string:
+ ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ case DW_FORM_block1:
+ len = *ptr++;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block:
+ case DW_FORM_exprloc:
+ len = read_uleb128 (ptr);
+ form = DW_FORM_block1;
+ break;
+ default:
+ abort ();
+ }
+
+ if (form == DW_FORM_block1)
+ ptr += len;
+ }
+ }
+
+ if (top_die == NULL || top_die->die_ck_state != CK_BAD)
+ {
+ for (child = die->die_child; child; child = child->die_sib)
+ {
+ unsigned int r
+ = checksum_ref_die (cu,
+ top_die ? top_die
+ : child->die_named_namespace
+ ? NULL : child, child,
+ second_idx, second_hash);
+ if (top_die == NULL)
+ assert (r == 0 && obstack_object_size (&ob) == 0);
+
+ if (ret == 0 || (r && r < ret))
+ ret = r;
+ if (top_die && top_die->die_ck_state == CK_BAD)
+ break;
+ }
+ }
+
+ if (top_die == die)
+ {
+ if (ret == 0)
+ {
+ if (second_hash != NULL)
+ return 0;
+ die->die_ref_seen = 0;
+ die->die_ref_hash_computed = 1;
+ obstack_blank_fast (&ob, -(int) sizeof (void *));
+ return 0;
+ }
+ assert (ret <= die->die_ref_seen);
+ if (ret == die->die_ref_seen)
+ {
+ unsigned int first = die->die_ref_seen - 1;
+ dw_die_ref *arr;
+ unsigned int count
+ = obstack_object_size (&ob) / sizeof (void *) - first;
+ unsigned int idx, minidx;
+ hashval_t ref_hash = 0;
+ bool bad = false;
+ bool no_multifile = false;
+
+ arr = (dw_die_ref *) obstack_base (&ob) + first;
+ for (i = 0; i < count; i++)
+ {
+ arr[i]->die_ref_seen = 0;
+ if (arr[i]->die_ck_state == CK_BAD)
+ bad = true;
+ else if (arr[i]->die_no_multifile)
+ no_multifile = true;
+ }
+ if (bad)
+ {
+ for (i = 0; i < count; i++)
+ arr[i]->die_ck_state = CK_BAD;
+ obstack_blank_fast (&ob, -(int) (count * sizeof (void *)));
+ return 0;
+ }
+ /* Find the DIE in the array with the smallest u.p1.die_hash. */
+ for (i = 0, minidx = -1U, bad = true; i < count; i++)
+ {
+ if (no_multifile)
+ arr[i]->die_no_multifile = 1;
+ if (minidx == -1U
+ || arr[i]->u.p1.die_hash < arr[minidx]->u.p1.die_hash)
+ {
+ minidx = i;
+ bad = false;
+ }
+ else if (arr[i]->u.p1.die_hash == arr[minidx]->u.p1.die_hash)
+ bad = true;
+ }
+ if (bad)
+ {
+ unsigned int iter, limv;
+ /* If there is more than one smallest u.p1.die_hash,
+ look for second (up to 6th) smallest u.p1.die_hash
+ if there is just one of that value. */
+ for (iter = 0; iter < 5; iter++)
+ {
+ limv = arr[minidx]->u.p1.die_hash;
+ for (i = 0, minidx = -1U, bad = true; i < count; i++)
+ if (arr[i]->u.p1.die_hash <= limv)
+ continue;
+ else if (minidx == -1U
+ || arr[i]->u.p1.die_hash
+ < arr[minidx]->u.p1.die_hash)
+ {
+ minidx = i;
+ bad = false;
+ }
+ else if (arr[i]->u.p1.die_hash
+ == arr[minidx]->u.p1.die_hash)
+ bad = true;
+ if (minidx == -1U || !bad)
+ break;
+ }
+ /* If all of 1st to 6th smallest u.p1.die_hash has more than
+ one DIE with that u.p1.die_hash, sort the array and find
+ the smallest u.p1.die_hash that only a single DIE has. */
+ if (minidx != -1U && iter == 5)
+ {
+ unsigned int j;
+ qsort (arr, count, sizeof (void *), checksum_ref_die_cmp);
+ for (i = 0, minidx = -1U; i < count; i = j)
+ {
+ if (i + 1 == count
+ || arr[i + 1]->u.p1.die_hash
+ != arr[i]->u.p1.die_hash)
+ {
+ minidx = i;
+ break;
+ }
+ for (j = i + 1; j < count; j++)
+ if (arr[j]->u.p1.die_hash != arr[i]->u.p1.die_hash)
+ break;
+ }
+ }
+ }
+ if (checksum_cycle_opt && minidx != -1U)
+ {
+ idx = 0;
+ checksum_ref_die (die_cu (arr[minidx]), arr[minidx],
+ arr[minidx], &idx, &ref_hash);
+ assert (arr == (dw_die_ref *) obstack_base (&ob) + first);
+ for (i = 0; i < count; i++)
+ {
+ arr[i]->u.p1.die_ref_hash
+ = iterative_hash_object (arr[i]->u.p1.die_ref_hash,
+ ref_hash);
+ arr[i]->die_ref_hash_computed = 1;
+ arr[i]->die_ref_seen = 0;
+ }
+ }
+ else
+ {
+ /* If we get here, all u.p1.die_hash values in the arr array
+ are used by more than one DIE. Do the more expensive
+ computation as fallback. */
+ for (i = 0; i < count; i++)
+ {
+ unsigned int j;
+ arr[i]->u.p1.die_ref_hash = arr[i]->u.p1.die_hash;
+ checksum_ref_die (die_cu (arr[i]), arr[i], arr[i], NULL,
+ &arr[i]->u.p1.die_ref_hash);
+ assert (arr == (dw_die_ref *) obstack_base (&ob) + first);
+ for (j = 0; j < count; j++)
+ arr[j]->die_ref_seen = 0;
+ }
+ for (i = 0; i < count; i++)
+ arr[i]->die_ref_hash_computed = 1;
+ }
+ obstack_blank_fast (&ob, -(int) (count * sizeof (void *)));
+ return 0;
+ }
+ }
+ return ret;
+}
+
+/* Hash function for dup_htab. u.p1.die_ref_hash should have u.p1.die_hash
+ iteratively hashed into it already. */
+static hashval_t
+die_hash (const void *p)
+{
+ dw_die_ref die = (dw_die_ref) p;
+
+ return die->u.p1.die_ref_hash;
+}
+
+/* Freelist of !die->die_toplevel DIEs, chained through die_sib fields. */
+static dw_die_ref die_nontoplevel_freelist;
+/* Freelist of die->die_collapsed_child DIEs, chained through die_parent
+ fields. */
+static dw_die_ref die_collapsed_child_freelist;
+
+/* Return pointer after the attributes of a DIE from a cu with CU_VERSION
+ which uses abbrevs T and starts at PTR. */
+static unsigned char *
+skip_attrs_1 (unsigned int cu_version, struct abbrev_tag *t, unsigned char *ptr)
+{
+ unsigned int i;
+ for (i = 0; i < t->nattr; ++i)
+ ptr = skip_attr (cu_version, &t->attr[i], ptr);
+
+ return ptr;
+}
+
+/* Return pointer after the attributes of a DIE from CU which uses abbrevs
+ T and starts at PTR. */
+static unsigned char *
+skip_attrs (dw_cu_ref cu, struct abbrev_tag *t, unsigned char *ptr)
+{
+ return skip_attrs_1 (cu->cu_version, t, ptr);
+}
+
+/* Expand children of TOP_DIE that have been collapsed by
+ collapse_child. CHECKSUM is true if checksum should be
+ computed - expansion is performed during read_debug_info
+ when duplicates are looked for - or false, if the expansion
+ is performed late (e.g. during compute_abbrevs or write_{info,types}. */
+static void
+expand_child (dw_die_ref top_die, bool checksum)
+{
+ dw_cu_ref cu = die_cu (top_die);
+ dw_die_ref *diep = &top_die->die_child;
+ dw_die_ref parent = top_die, child;
+ unsigned char *ptr, *base;
+ struct abbrev_tag tag, *t;
+ dw_die_ref die;
+ unsigned int tick = checksum ? top_die->u.p1.die_enter + 1 : 0;
+
+ if (unlikely (cu->cu_kind == CU_TYPES))
+ base = debug_sections[DEBUG_TYPES].data;
+ else
+ base = debug_sections[DEBUG_INFO].data;
+ ptr = base + top_die->die_offset;
+ if (likely (checksum))
+ ptr += top_die->die_size;
+ else
+ {
+ t = top_die->die_abbrev;
+ skip_leb128 (ptr);
+ ptr = skip_attrs (cu, t, ptr);
+ }
+
+ while (1)
+ {
+ unsigned int die_offset = ptr - base;
+ void **slot;
+ struct dw_die diebuf;
+ dw_die_ref collapsed;
+
+ tag.entry = read_uleb128 (ptr);
+ if (tag.entry == 0)
+ {
+ if (parent == top_die)
+ break;
+ diep = &parent->die_sib;
+ if (checksum)
+ parent->u.p1.die_exit = tick++;
+ parent = parent->die_parent;
+ continue;
+ }
+
+ diebuf.die_offset = die_offset;
+ slot = htab_find_slot_with_hash (cu->cu_kind == CU_TYPES
+ ? types_off_htab : off_htab,
+ &diebuf, off_hash (&diebuf), NO_INSERT);
+ if (slot == NULL)
+ die = NULL;
+ else
+ die = (dw_die_ref) *slot;
+ if (die != NULL && !die->die_collapsed_child)
+ {
+ *diep = die;
+ die->die_parent = parent;
+ die->die_ck_state = CK_UNKNOWN;
+ die->die_ref_seen = 0;
+ assert (!checksum || die->u.p1.die_enter == tick);
+ if (die->die_abbrev->children)
+ {
+ diep = &die->die_child;
+ parent = die;
+ }
+ else
+ {
+ diep = &die->die_sib;
+ assert (!checksum || die->u.p1.die_exit == tick);
+ }
+ tick++;
+ if (checksum)
+ ptr = base + die_offset + die->die_size;
+ else
+ ptr = skip_attrs (cu, die->die_abbrev, ptr);
+ continue;
+ }
+
+ collapsed = die;
+ t = htab_find_with_hash (cu->cu_abbrev, &tag, tag.entry);
+ if (die_nontoplevel_freelist)
+ {
+ die = die_nontoplevel_freelist;
+ die_nontoplevel_freelist = die->die_sib;
+ }
+ else
+ die = pool_alloc (dw_die, offsetof (struct dw_die, die_dup));
+ memset (die, '\0', offsetof (struct dw_die, die_dup));
+ *diep = die;
+ die->die_tag = t->tag;
+ die->die_abbrev = t;
+ die->die_offset = die_offset;
+ die->die_parent = parent;
+ if (checksum)
+ {
+ die->u.p1.die_enter = tick;
+ die->u.p1.die_exit = tick++;
+ }
+ if (t->children)
+ {
+ diep = &die->die_child;
+ parent = die;
+ }
+ else
+ diep = &die->die_sib;
+
+ ptr = skip_attrs (cu, t, ptr);
+ die->die_size = (ptr - base) - die_offset;
+ if (collapsed != NULL)
+ {
+ die->die_referenced = collapsed->die_referenced;
+ *slot = (void *) die;
+ memset (collapsed, '\0', offsetof (struct dw_die, die_child));
+ collapsed->die_parent = die_collapsed_child_freelist;
+ die_collapsed_child_freelist = collapsed;
+ }
+ }
+ assert (!checksum || top_die->u.p1.die_exit == tick);
+ top_die->die_collapsed_children = 0;
+ if (checksum && likely (cu->cu_kind != CU_TYPES))
+ for (child = top_die->die_child; child; child = child->die_sib)
+ checksum_die (NULL, cu, top_die, child);
+}
+
+/* Call expand_child on all collapsed toplevel children DIEs. */
+static bool
+expand_children (dw_die_ref die)
+{
+ dw_die_ref child;
+ bool ret = false;
+ for (child = die->die_child; child; child = child->die_sib)
+ if (child->die_named_namespace)
+ ret |= expand_children (child);
+ else if (child->die_collapsed_children)
+ {
+ expand_child (child, false);
+ ret = true;
+ }
+ return ret;
+}
+
+static unsigned odr_phase;
+
+/* Return 1 if DIE1 and DIE2 match. TOP_DIE1 and TOP_DIE2
+ is the corresponding ultimate parent with die_toplevel
+ set. u.p1.die_hash and u.p1.die_ref_hash hashes should
+ hopefully ensure that in most cases this function actually
+ just verifies matching. */
+static int
+die_eq_1 (dw_cu_ref cu1, dw_cu_ref cu2,
+ dw_die_ref top_die1, dw_die_ref top_die2,
+ dw_die_ref die1, dw_die_ref die2)
+{
+ struct abbrev_tag *t1, *t2;
+ unsigned int i, j;
+ unsigned char *ptr1, *ptr2;
+ dw_die_ref ref1, ref2;
+ dw_die_ref child1, child2;
+ bool only_compare_name_p;
+
+#define FAIL goto fail
+ if (die1 == die2 || die_safe_dup (die2) == die1)
+ return 1;
+ if (die1->u.p1.die_hash != die2->u.p1.die_hash
+ || die1->u.p1.die_ref_hash != die2->u.p1.die_ref_hash
+ || die1->die_tag != die2->die_tag
+ || (!odr && (die1->u.p1.die_exit - die1->u.p1.die_enter
+ != die2->u.p1.die_exit - die2->u.p1.die_enter))
+ || die_safe_dup (die2) != NULL
+ || die1->die_ck_state != CK_KNOWN
+ || die2->die_ck_state != CK_KNOWN
+ || die1->die_toplevel != die2->die_toplevel)
+ return 0;
+ assert (!die1->die_root && !die2->die_root);
+
+ if (uni_lang_p && die1 == top_die1 && die2 == top_die2
+ && cu1->lang != cu2->lang)
+ return 0;
+
+ only_compare_name_p
+ = odr && die1->die_odr_state != ODR_NONE && die2->die_odr_state != ODR_NONE;
+
+ if (only_compare_name_p && odr_phase == 1)
+ {
+ const char *name1 = get_AT_string (die1, DW_AT_name);
+ const char *name2 = get_AT_string (die2, DW_AT_name);
+ // TODO: Handle DW_AT_linkage_name?
+ if (name1 == NULL || name2 == NULL)
+ return 0;
+ if (strcmp (name1, name2) != 0)
+ return 0;
+ }
+ else if (die1->u.p1.die_exit - die1->u.p1.die_enter
+ != die2->u.p1.die_exit - die2->u.p1.die_enter)
+ return 0;
+
+ if (only_compare_name_p && odr_phase == 2
+ && die1->die_odr_state == ODR_DEF && die2->die_odr_state == ODR_DEF)
+ {
+ if (die1->u.p1.die_hash2 != die2->u.p1.die_hash2)
+ return 0;
+ }
+
+ t1 = die1->die_abbrev;
+ t2 = die2->die_abbrev;
+ if (likely (!fi_multifile))
+ {
+ ptr1 = debug_sections[DEBUG_INFO].data + die1->die_offset;
+ ptr2 = debug_sections[DEBUG_INFO].data + die2->die_offset;
+ }
+ else
+ {
+ if (cu1->cu_kind == CU_ALT)
+ ptr1 = alt_data[DEBUG_INFO];
+ else
+ ptr1 = debug_sections[DEBUG_INFO].data;
+ ptr1 += die1->die_offset;
+ if (cu2->cu_kind == CU_ALT)
+ ptr2 = alt_data[DEBUG_INFO];
+ else
+ ptr2 = debug_sections[DEBUG_INFO].data;
+ ptr2 += die2->die_offset;
+ }
+ skip_leb128 (ptr1);
+ skip_leb128 (ptr2);
+ i = 0;
+ j = 0;
+ if (die1->die_toplevel)
+ {
+ for (ref1 = die1->die_parent, ref2 = die2->die_parent; ref1 && ref2; )
+ {
+ const char *name1, *name2;
+ if ((ref1->die_tag == DW_TAG_compile_unit
+ || ref1->die_tag == DW_TAG_partial_unit)
+ && (ref2->die_tag == DW_TAG_compile_unit
+ || ref2->die_tag == DW_TAG_partial_unit))
+ break;
+ if (ref1->die_tag != ref2->die_tag)
+ return 0;
+ if (!ref1->die_named_namespace || !ref2->die_named_namespace)
+ return 0;
+ name1 = get_AT_string (ref1, DW_AT_name);
+ name2 = get_AT_string (ref2, DW_AT_name);
+ if (strcmp (name1, name2))
+ return 0;
+ ref1 = ref1->die_root ? NULL : ref1->die_parent;
+ ref2 = ref2->die_root ? NULL : ref2->die_parent;
+ }
+ if (ref1 == NULL || ref2 == NULL)
+ return 0;
+ /* For each toplevel die seen, record optimistically
+ that we expect them to match, to avoid recursing
+ on it again. If non-match is determined later,
+ die_eq wrapper undoes this (which is why the DIE
+ pointer is added to the vector). */
+ if (!die2->die_op_type_referenced)
+ die2->die_remove = 1;
+ obstack_ptr_grow (&ob, die2);
+ if (likely (die2->die_nextdup == NULL))
+ {
+ die2->die_dup = die1;
+ die2->die_nextdup = die1->die_nextdup;
+ obstack_ptr_grow (&ob, NULL);
+ }
+ else
+ {
+ dw_die_ref next;
+ for (next = die2; next->die_nextdup; next = next->die_nextdup)
+ next->die_dup = die1;
+ next->die_dup = die1;
+ next->die_nextdup = die1->die_nextdup;
+ obstack_ptr_grow (&ob, next);
+ }
+ die1->die_nextdup = die2;
+ }
+
+ if (only_compare_name_p && odr_phase == 1)
+ return 1;
+
+ while (1)
+ {
+ uint32_t form1, form2;
+ size_t len = 0;
+ unsigned char *old_ptr1;
+ unsigned char *old_ptr2;
+ uint64_t value1, value2;
+
+ while (i < t1->nattr && t1->attr[i].attr == DW_AT_sibling)
+ {
+ form1 = t1->attr[i].form;
+ while (form1 == DW_FORM_indirect)
+ form1 = read_uleb128 (ptr1);
+ switch (form1)
+ {
+ case DW_FORM_ref_udata: skip_leb128 (ptr1); break;
+ case DW_FORM_ref1: ptr1++; break;
+ case DW_FORM_ref2: read_16 (ptr1); break;
+ case DW_FORM_ref4: read_32 (ptr1); break;
+ case DW_FORM_ref8: read_64 (ptr1); break;
+ default: FAIL;
+ }
+ i++;
+ }
+ while (j < t2->nattr && t2->attr[j].attr == DW_AT_sibling)
+ {
+ form2 = t2->attr[j].form;
+ while (form2 == DW_FORM_indirect)
+ form2 = read_uleb128 (ptr2);
+ switch (form2)
+ {
+ case DW_FORM_ref_udata: skip_leb128 (ptr2); break;
+ case DW_FORM_ref1: ptr2++; break;
+ case DW_FORM_ref2: read_16 (ptr2); break;
+ case DW_FORM_ref4: read_32 (ptr2); break;
+ case DW_FORM_ref8: read_64 (ptr2); break;
+ default: FAIL;
+ }
+ j++;
+ }
+ if (i == t1->nattr)
+ {
+ if (j != t2->nattr)
+ FAIL;
+ break;
+ }
+ if (j == t2->nattr)
+ FAIL;
+
+ if (t1->attr[i].attr != t2->attr[j].attr)
+ FAIL;
+
+ form1 = t1->attr[i].form;
+ while (form1 == DW_FORM_indirect)
+ form1 = read_uleb128 (ptr1);
+ form2 = t2->attr[j].form;
+ while (form2 == DW_FORM_indirect)
+ form2 = read_uleb128 (ptr2);
+ old_ptr1 = ptr1;
+ old_ptr2 = ptr2;
+
+ switch (t1->attr[i].attr)
+ {
+ case DW_AT_sibling:
+ case DW_AT_low_pc:
+ case DW_AT_high_pc:
+ case DW_AT_entry_pc:
+ case DW_AT_ranges:
+ case DW_AT_call_return_pc:
+ case DW_AT_call_pc:
+ /* We shouldn't be hitting DIEs with attributes referencing
+ addresses and we should have removed DW_AT_subling. */
+ abort ();
+ case DW_AT_decl_file:
+ case DW_AT_call_file:
+ switch (form1)
+ {
+ case DW_FORM_data1: value1 = read_8 (ptr1); break;
+ case DW_FORM_data2: value1 = read_16 (ptr1); break;
+ case DW_FORM_data4: value1 = read_32 (ptr1); break;
+ case DW_FORM_data8: value1 = read_64 (ptr1); break;
+ case DW_FORM_udata: value1 = read_uleb128 (ptr1); break;
+ case DW_FORM_sdata: value1 = read_sleb128 (ptr1); break;
+ case DW_FORM_implicit_const: value1 = t1->values[i]; break;
+ default: abort ();
+ }
+ switch (form2)
+ {
+ case DW_FORM_data1: value2 = read_8 (ptr2); break;
+ case DW_FORM_data2: value2 = read_16 (ptr2); break;
+ case DW_FORM_data4: value2 = read_32 (ptr2); break;
+ case DW_FORM_data8: value2 = read_64 (ptr2); break;
+ case DW_FORM_udata: value2 = read_uleb128 (ptr2); break;
+ case DW_FORM_sdata: value2 = read_sleb128 (ptr2); break;
+ case DW_FORM_implicit_const: value2 = t2->values[j]; break;
+ default: abort ();
+ }
+ if (ignore_locus)
+ {
+ i++;
+ j++;
+ continue;
+ }
+ if ((value1 == 0) ^ (value2 == 0))
+ FAIL;
+ if (value1 != 0)
+ {
+ struct dw_file *cu_file1
+ = &cu1->cu_files[value1 - 1];
+ struct dw_file *cu_file2
+ = &cu2->cu_files[value2 - 1];
+
+ if (cu_file1->time != cu_file2->time
+ || cu_file1->size != cu_file2->size
+ || strcmp (cu_file1->file, cu_file2->file))
+ FAIL;
+
+ if (cu_file1->dir != NULL)
+ {
+ if (cu_file2->dir == NULL
+ || strcmp (cu_file1->dir, cu_file2->dir))
+ FAIL;
+ }
+ else if (cu_file2->dir != NULL)
+ FAIL;
+ /* Ignore DW_AT_comp_dir for DW_AT_*_file <built-in>
+ etc. if immediately followed by DW_AT_*_line 0. */
+ else if (cu_file1->file_angle_brackets_encapsulated_no_slash
+ && i + 1 < t1->nattr
+ && j + 1 < t2->nattr
+ && t1->attr[i + 1].attr
+ == (t1->attr[i].attr == DW_AT_decl_file
+ ? DW_AT_decl_line : DW_AT_call_line)
+ && t1->attr[i + 1].form == DW_FORM_data1
+ && t1->attr[i + 1].attr == t2->attr[j + 1].attr
+ && t2->attr[j + 1].form == DW_FORM_data1
+ && *ptr1 == 0
+ && *ptr2 == 0)
+ {
+ i++;
+ j++;
+ continue;
+ }
+
+ if ((cu_file1->dir ? cu_file1->dir[0] : cu_file1->file[0])
+ != '/')
+ {
+ if (cu1->cu_comp_dir != NULL)
+ {
+ if (cu2->cu_comp_dir == NULL
+ || strcmp (cu1->cu_comp_dir, cu2->cu_comp_dir))
+ FAIL;
+ }
+ else if (cu2->cu_comp_dir != NULL)
+ FAIL;
+ }
+ }
+ i++;
+ j++;
+ continue;
+ case DW_AT_decl_line:
+ case DW_AT_decl_column:
+ case DW_AT_call_line:
+ case DW_AT_call_column:
+ if (ignore_locus)
+ {
+ old_ptr1 = NULL;
+ break;
+ }
+ switch (form1)
+ {
+ case DW_FORM_data1: value1 = read_8 (ptr1); break;
+ case DW_FORM_data2: value1 = read_16 (ptr1); break;
+ case DW_FORM_data4: value1 = read_32 (ptr1); break;
+ case DW_FORM_data8: value1 = read_64 (ptr1); break;
+ case DW_FORM_udata: value1 = read_uleb128 (ptr1); break;
+ case DW_FORM_sdata: value1 = read_sleb128 (ptr1); break;
+ case DW_FORM_implicit_const: value1 = t1->values[i]; break;
+ default: abort ();
+ }
+ switch (form2)
+ {
+ case DW_FORM_data1: value2 = read_8 (ptr2); break;
+ case DW_FORM_data2: value2 = read_16 (ptr2); break;
+ case DW_FORM_data4: value2 = read_32 (ptr2); break;
+ case DW_FORM_data8: value2 = read_64 (ptr2); break;
+ case DW_FORM_udata: value2 = read_uleb128 (ptr2); break;
+ case DW_FORM_sdata: value2 = read_sleb128 (ptr2); break;
+ case DW_FORM_implicit_const: value2 = t2->values[j]; break;
+ default: abort ();
+ }
+ if (value1 != value2)
+ FAIL;
+ i++;
+ j++;
+ continue;
+ default:
+ break;
+ }
+
+ switch (form1)
+ {
+ case DW_FORM_ref_addr:
+ if (likely (!op_multifile && !rd_multifile && !fi_multifile))
+ {
+ if (form1 != form2)
+ FAIL;
+ break;
+ }
+ /* FALLTHRU */
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ switch (form2)
+ {
+ case DW_FORM_ref_addr:
+ if (likely (!op_multifile && !rd_multifile && !fi_multifile))
+ FAIL;
+ break;
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ break;
+ default:
+ FAIL;
+ }
+ break;
+ default:
+ if (form1 != form2)
+ FAIL;
+ break;
+ }
+
+ switch (form1)
+ {
+ case DW_FORM_addr:
+ ptr1 += ptr_size;
+ ptr2 += ptr_size;
+ break;
+ case DW_FORM_flag_present:
+ break;
+ case DW_FORM_implicit_const:
+ if ((!ignore_locus || old_ptr1) && t1->values[i] != t2->values[j])
+ FAIL;
+ break;
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ ++ptr1;
+ ++ptr2;
+ break;
+ case DW_FORM_data2:
+ ptr1 += 2;
+ ptr2 += 2;
+ break;
+ case DW_FORM_data4:
+ case DW_FORM_sec_offset:
+ ptr1 += 4;
+ ptr2 += 4;
+ break;
+ case DW_FORM_data8:
+ case DW_FORM_ref_sig8:
+ ptr1 += 8;
+ ptr2 += 8;
+ break;
+ case DW_FORM_data16:
+ ptr1 += 16;
+ ptr2 += 16;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ skip_leb128 (ptr1);
+ skip_leb128 (ptr2);
+ break;
+ case DW_FORM_strp:
+ if (unlikely (op_multifile || rd_multifile || fi_multifile))
+ {
+ value1 = read_32 (ptr1);
+ value2 = read_32 (ptr2);
+ if (fi_multifile)
+ {
+ if (strcmp ((char *) (cu1->cu_kind == CU_ALT
+ ? alt_data[DEBUG_STR]
+ : debug_sections[DEBUG_STR].data)
+ + value1,
+ (char *) (cu2->cu_kind == CU_ALT
+ ? alt_data[DEBUG_STR]
+ : debug_sections[DEBUG_STR].data)
+ + value2) != 0)
+ FAIL;
+ i++;
+ j++;
+ continue;
+ }
+ if (strcmp ((char *) debug_sections[DEBUG_STR].data + value1,
+ (char *) debug_sections[DEBUG_STR].data + value2)
+ != 0)
+ FAIL;
+ i++;
+ j++;
+ continue;
+ }
+ ptr1 += 4;
+ ptr2 += 4;
+ break;
+ case DW_FORM_line_strp:
+ ptr1 += 4;
+ ptr2 += 4;
+ break;
+ case DW_FORM_string:
+ ptr1 = (unsigned char *) strchr ((char *)ptr1, '\0') + 1;
+ ptr2 = (unsigned char *) strchr ((char *)ptr2, '\0') + 1;
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ case DW_FORM_block1:
+ len = *ptr1++;
+ ptr1 += len;
+ len = *ptr2++;
+ ptr2 += len;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (ptr1);
+ ptr1 += len;
+ len = read_16 (ptr2);
+ ptr2 += len;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (ptr1);
+ ptr1 += len;
+ len = read_32 (ptr2);
+ ptr2 += len;
+ break;
+ case DW_FORM_block:
+ case DW_FORM_exprloc:
+ len = read_uleb128 (ptr1);
+ ptr1 += len;
+ len = read_uleb128 (ptr2);
+ ptr2 += len;
+ break;
+ case DW_FORM_ref_addr:
+ if (likely (!op_multifile && !rd_multifile && !fi_multifile))
+ {
+ ptr1 += cu1->cu_version == 2 ? ptr_size : 4;
+ ptr2 += cu2->cu_version == 2 ? ptr_size : 4;
+ break;
+ }
+ /* FALLTHRU */
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ switch (form1)
+ {
+ case DW_FORM_ref_addr:
+ value1 = read_size (ptr1, cu1->cu_version == 2
+ ? ptr_size : 4)
+ - cu1->cu_offset;
+ ptr1 += cu1->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_ref_udata:
+ value1 = read_uleb128 (ptr1);
+ break;
+ case DW_FORM_ref1:
+ value1 = read_8 (ptr1);
+ break;
+ case DW_FORM_ref2:
+ value1 = read_16 (ptr1);
+ break;
+ case DW_FORM_ref4:
+ value1 = read_32 (ptr1);
+ break;
+ case DW_FORM_ref8:
+ value1 = read_64 (ptr1);
+ break;
+ default: abort ();
+ }
+ ref1 = off_htab_lookup (cu1, cu1->cu_offset + value1);
+ switch (form2)
+ {
+ case DW_FORM_ref_addr:
+ value2 = read_size (ptr2, cu2->cu_version == 2
+ ? ptr_size : 4)
+ - cu2->cu_offset;
+ ptr2 += cu2->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_ref_udata:
+ value2 = read_uleb128 (ptr2);
+ break;
+ case DW_FORM_ref1:
+ value2 = read_8 (ptr2);
+ break;
+ case DW_FORM_ref2:
+ value2 = read_16 (ptr2);
+ break;
+ case DW_FORM_ref4:
+ value2 = read_32 (ptr2);
+ break;
+ case DW_FORM_ref8:
+ value2 = read_64 (ptr2);
+ break;
+ default: abort ();
+ }
+ ref2 = off_htab_lookup (cu2, cu2->cu_offset + value2);
+ assert (ref1 != NULL && ref2 != NULL);
+ if (unlikely (op_multifile || low_mem))
+ {
+ if (die1->die_collapsed_children && ref1->die_collapsed_child)
+ {
+ expand_child (die1, true);
+ ref1 = off_htab_lookup (cu1, cu1->cu_offset + value1);
+ }
+ assert (ref2->die_collapsed_child == 0);
+ }
+ if (likely (!ref1->die_collapsed_child)
+ && die_cu (ref1) == cu1
+ && ref1->u.p1.die_enter >= top_die1->u.p1.die_enter
+ && ref1->u.p1.die_exit <= top_die1->u.p1.die_exit)
+ {
+ /* A reference into a subdie of the DIE being compared. */
+ if (die_cu (ref2) != cu2
+ || ref1->u.p1.die_enter - top_die1->u.p1.die_enter
+ != ref2->u.p1.die_enter - top_die2->u.p1.die_enter
+ || top_die1->u.p1.die_exit - ref1->u.p1.die_exit
+ != top_die2->u.p1.die_exit - ref2->u.p1.die_exit)
+ FAIL;
+ }
+ else
+ {
+ dw_die_ref reft1 = ref1, reft2 = ref2;
+ dw_cu_ref refcu1, refcu2;
+ while (reft1->die_toplevel == 0)
+ reft1 = reft1->die_parent;
+ while (reft2->die_toplevel == 0)
+ reft2 = reft2->die_parent;
+ if (unlikely (ref1->die_collapsed_child))
+ {
+ if (ref1->die_tag
+ != ref2->u.p1.die_enter - reft2->u.p1.die_enter)
+ FAIL;
+ }
+ else if (ref1->u.p1.die_enter - reft1->u.p1.die_enter
+ != ref2->u.p1.die_enter - reft2->u.p1.die_enter)
+ FAIL;
+ refcu1 = die_cu (reft1);
+ refcu2 = die_cu (reft2);
+ if (unlikely (refcu1->cu_chunk == refcu2->cu_chunk)
+ && likely (!fi_multifile))
+ {
+ if (reft1->die_dup
+ && die_cu (reft1->die_dup)->cu_chunk
+ == refcu1->cu_chunk)
+ reft1 = reft1->die_dup;
+ if (reft2->die_dup
+ && die_cu (reft2->die_dup)->cu_chunk
+ == refcu2->cu_chunk)
+ reft2 = reft2->die_dup;
+ if (reft2->die_offset < reft1->die_offset)
+ {
+ dw_die_ref tem = reft1;
+ reft1 = reft2;
+ reft2 = tem;
+ }
+ if (reft1->die_dup == NULL && reft2->die_dup != NULL)
+ {
+ dw_die_ref tem = reft1;
+ reft1 = reft2;
+ reft2 = tem;
+ }
+ }
+ /* If reft1 (die1 or whatever refers to it is already
+ in the hash table) already has a dup, follow to that
+ dup. Don't do the same for reft2, {{top_,}die,reft,child}2
+ should always be from the current CU. */
+ if (reft1->die_dup)
+ reft1 = reft1->die_dup;
+ refcu1 = die_cu (reft1);
+ refcu2 = die_cu (reft2);
+ if (die_eq_1 (refcu1, refcu2, reft1, reft2, reft1, reft2) == 0)
+ FAIL;
+ }
+ i++;
+ j++;
+ continue;
+ default:
+ abort ();
+ }
+
+ if ((!ignore_locus || old_ptr1)
+ && (ptr1 - old_ptr1 != ptr2 - old_ptr2
+ || memcmp (old_ptr1, old_ptr2, ptr1 - old_ptr1)))
+ FAIL;
+ i++;
+ j++;
+ }
+
+ if (unlikely (op_multifile || low_mem))
+ {
+ if (die1->die_collapsed_children)
+ expand_child (die1, true);
+ assert (die2->die_collapsed_children == 0);
+ }
+
+ for (child1 = die1->die_child, child2 = die2->die_child;
+ child1 && child2;
+ child1 = child1->die_sib, child2 = child2->die_sib)
+ if (die_eq_1 (cu1, cu2, top_die1, top_die2, child1, child2) == 0)
+ FAIL;
+
+ if (child1 || child2)
+ {
+ fail:
+ return 0;
+ }
+
+ if (unlikely (fi_multifile))
+ assert (cu1->cu_kind == CU_ALT && cu2->cu_kind != CU_ALT);
+ return 1;
+}
+
+/* Wrapper around die_eq_1, used as equality function in
+ dup_htab hash table. If zero (non-match) is returned and
+ any toplevel DIEs have been pushed to the vector in ob obstack,
+ undo the optimistic assignment of die_dup and die_nextdup. */
+static int
+die_eq (const void *p, const void *q)
+{
+ dw_die_ref die1 = (dw_die_ref) p;
+ dw_die_ref die2 = (dw_die_ref) q;
+ dw_die_ref *arr;
+ unsigned int i, count;
+ int ret;
+
+ if (die1->u.p1.die_hash != die2->u.p1.die_hash
+ || die1->u.p1.die_ref_hash != die2->u.p1.die_ref_hash)
+ return 0;
+ ret = die_eq_1 (die_cu (die1), die_cu (die2), die1, die2, die1, die2);
+ count = obstack_object_size (&ob) / sizeof (void *);
+ arr = (dw_die_ref *) obstack_finish (&ob);
+ if (!ret)
+ for (i = count; i;)
+ {
+ dw_die_ref die;
+ i -= 2;
+ die = arr[i]->die_dup;
+ if (likely (arr[i + 1] == NULL))
+ {
+ die->die_nextdup = arr[i]->die_nextdup;
+ arr[i]->die_nextdup = NULL;
+ arr[i]->die_dup = NULL;
+ }
+ else
+ {
+ dw_die_ref next;
+
+ assert (die->die_nextdup == arr[i]);
+ for (next = arr[i]->die_nextdup;
+ next != arr[i + 1];
+ next = next->die_nextdup)
+ {
+ assert (next->die_dup == die);
+ next->die_dup = arr[i];
+ }
+ assert (next->die_dup == die);
+ next->die_dup = arr[i];
+ die->die_nextdup = next->die_nextdup;
+ next->die_nextdup = NULL;
+ arr[i]->die_dup = NULL;
+ }
+ arr[i]->die_remove = 0;
+ }
+ obstack_free (&ob, (void *) arr);
+ return ret;
+}
+
+/* Hash table for finding of matching toplevel DIEs (and all
+ its children together with it). */
+static htab_t dup_htab;
+
+/* After read_multifile dup_htab is moved to this variable. */
+static htab_t alt_dup_htab;
+
+/* First CU, start of the linked list of CUs, and the tail
+ of that list. Initially this contains just the original
+ CUs, later on newly created partial units are added
+ to the beginning of the list and optionally .debug_types
+ CUs are added to its tail. */
+static dw_cu_ref first_cu, last_cu;
+
+/* After read_multifile first_cu is copied to this variable. */
+static dw_cu_ref alt_first_cu;
+
+/* Compute approximate size of DIE and all its children together. */
+static unsigned long
+calc_sizes (dw_die_ref die)
+{
+ unsigned long ret = die->die_size;
+ dw_die_ref child;
+ if (wr_multifile ? die->die_no_multifile : die->die_remove)
+ return 0;
+ for (child = die->die_child; child; child = child->die_sib)
+ ret += calc_sizes (child);
+ return ret;
+}
+
+/* Verify the duplicate chains starting at DIE. If ORDERED, also check that
+ the duplicate chain is in the correct order. */
+static void
+verify_dups (dw_die_ref die, bool ordered)
+{
+ dw_die_ref d, prev;
+
+ assert (die->die_dup == NULL);
+ assert (die->die_collapsed_children == 0);
+ assert (die->die_remove == 0);
+
+ for (prev = die, d = prev->die_nextdup;
+ d;
+ prev = d, d = prev->die_nextdup)
+ {
+ if (ordered)
+ assert (die_cu (prev)->cu_chunk <= die_cu (d)->cu_chunk);
+ assert (d->die_offset != -1U);
+ assert (d->die_dup == die);
+ assert (d->die_remove != d->die_op_type_referenced);
+ assert (d->die_tag == die->die_tag);
+ }
+}
+
+/* Walk toplevel DIEs in tree rooted by PARENT, and see if they
+ match previously processed DIEs. */
+static int
+find_dups (dw_die_ref parent)
+{
+ void **slot;
+ dw_die_ref child;
+
+ if (stats_p && parent->die_root)
+ stats->root_cnt++;
+
+ for (child = parent->die_child; child; child = child->die_sib)
+ {
+ if (child->die_ck_state == CK_KNOWN)
+ {
+ if (stats_p)
+ stats->lower_toplevel_with_checksum++;
+ if (child->die_dup != NULL)
+ continue;
+ slot = htab_find_slot_with_hash (dup_htab, child,
+ child->u.p1.die_ref_hash,
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot == NULL)
+ *slot = child;
+ }
+ else if (child->die_named_namespace)
+ {
+ if (stats_p)
+ stats->namespace_cnt++;
+ if (find_dups (child))
+ return 1;
+ }
+ else if (stats_p)
+ stats->lower_toplevel++;
+ }
+ return 0;
+}
+
+/* Like find_dups, but for the last multifile optimization phase,
+ where it only looks at duplicates in the common .debug_info
+ section. */
+static int
+find_dups_fi (dw_die_ref parent)
+{
+ dw_die_ref child;
+
+ for (child = parent->die_child; child; child = child->die_sib)
+ {
+ if (child->die_ck_state == CK_KNOWN)
+ {
+ if (child->die_dup != NULL)
+ continue;
+ htab_find_with_hash (alt_dup_htab, child, child->u.p1.die_ref_hash);
+ }
+ else if (child->die_named_namespace)
+ if (find_dups_fi (child))
+ return 1;
+ }
+ return 0;
+}
+
+/* Return value of DW_AT_name for DIE, or for its specification or abstract
+ origin. */
+static const char *
+get_name (dw_die_ref die)
+{
+ if (die->die_collapsed_child)
+ return NULL;
+ const char *name = get_AT_string (die, DW_AT_name);
+ if (name)
+ return name;
+ dw_cu_ref cu = die_cu (die);
+ bool present;
+ enum dwarf_form form;
+ unsigned int value = get_AT_int (die, DW_AT_specification, &present, &form);
+ if (present)
+ {
+ dw_die_ref ref;
+ if (form != DW_FORM_ref_addr)
+ value = cu->cu_offset + value;
+ ref = off_htab_lookup (cu, value);
+ if (ref)
+ return get_name (ref);
+ }
+ value = get_AT_int (die, DW_AT_abstract_origin, &present, &form);
+ if (present)
+ {
+ dw_die_ref ref;
+ if (form != DW_FORM_ref_addr)
+ value = cu->cu_offset + value;
+ ref = off_htab_lookup (die_cu (die), value);
+ if (ref)
+ return get_name (ref);
+ }
+ return NULL;
+}
+
+/* Dump type of DIE to stderr. */
+static void
+dump_type (dw_die_ref die)
+{
+ bool present;
+ enum dwarf_form form;
+ if (die->die_collapsed_child)
+ return;
+ unsigned int value = get_AT_int (die, DW_AT_type, &present, &form);
+ if (!present)
+ return;
+
+ dw_cu_ref cu = die_cu (die);
+ if (cu == NULL)
+ return;
+
+ dw_die_ref ref;
+ if (form != DW_FORM_ref_addr)
+ value = cu->cu_offset + value;
+ fprintf (stderr, " (type: %x", value);
+ ref = off_htab_lookup (cu, value);
+ if (ref != NULL && !ref->die_collapsed_child)
+ {
+ const char *type_name = get_name (ref);
+ if (type_name)
+ fprintf (stderr, " %s", type_name);
+ fprintf (stderr, " %s", get_DW_TAG_name (ref->die_tag) + 7);
+ dump_type (ref);
+ }
+ fprintf (stderr, ")");
+}
+
+/* Dump DIE to stderr with INDENT. */
+static void
+dump_die_with_indent (int indent, dw_die_ref die)
+{
+ if (die == NULL)
+ fprintf (stderr, "%*s null", indent, "");
+ else if (die->die_offset == -1U)
+ {
+ fprintf (stderr, "%*s -1 %s", indent, "",
+ get_DW_TAG_name (die->die_tag) + 7);
+ dw_die_ref d = die->die_nextdup;
+ while (d)
+ {
+ const char *name = get_name (d);
+ fprintf (stderr, " -> %x %s %s", d->die_offset, name ? name : "",
+ get_DW_TAG_name (d->die_tag) + 7);
+ d = d->die_nextdup;
+ }
+ }
+ else if (die->die_collapsed_child)
+ {
+ fprintf (stderr, "%*s %x %c", indent, "", die->die_offset,
+ die->die_ck_state == CK_KNOWN ? 'O' : 'X');
+ }
+ else
+ {
+ const char *name = get_name (die);
+ fprintf (stderr, "%*s %x %c %x", indent, "", die->die_offset,
+ die->die_ck_state == CK_KNOWN ? 'O' : 'X',
+ (unsigned) die->u.p1.die_hash);
+ if (odr && die->die_odr_state != ODR_NONE
+ && die->die_odr_state != ODR_UNKNOWN)
+ fprintf (stderr, "(%x)", (unsigned) die->u.p1.die_hash2);
+ fprintf (stderr, " %x %s %s", (unsigned) die->u.p1.die_ref_hash,
+ name ? name : "", get_DW_TAG_name (die->die_tag) + 7);
+ dump_type (die);
+ }
+ fprintf (stderr, "\n");
+}
+
+/* Dump DIE to stderr. */
+static void
+dump_die (dw_die_ref die)
+{
+ dump_die_with_indent (0, die);
+}
+
+static void
+dump_dups (dw_die_ref die)
+{
+ dw_die_ref d;
+ for (d = die; d; d = d->die_nextdup)
+ dump_die (d);
+}
+
+/* Dump DIE tree at tree depth DEPTH. */
+static void
+dump_dies (int depth, dw_die_ref die)
+{
+ dw_die_ref child;
+ dump_die_with_indent (depth, die);
+ for (child = die->die_child; child; child = child->die_sib)
+ dump_dies (depth + 1, child);
+}
+
+/* Hash table for .debug_str. Depending on multifile optimization
+ phase this hash table has 3 different hash/equality functions.
+ The first set is used to record tail optimized strings, during
+ write_multifile the whole .debug_str section is written as is,
+ plus then all the strings which are just suffixes of other
+ strings. E.g. if .debug_str section contains "foobar" string
+ and .debug_info section refers to the whole "foobar" string
+ as well as "bar" by referring to "foobar" + 3.
+ The second set is used during op_multifile and fi_multifile,
+ noting each string and in addition to that how many times it
+ has been seen (0, 1 or more than 1). If 0 then it isn't present
+ in the hash table, 1 has lowest bit of new_off clear, more than 1
+ the LSB of new_off is set.
+ The final set is used during finalize_strp and afterwards, it is
+ then used to map strings to their location in the new .debug_str
+ section. */
+static htab_t strp_htab;
+/* Current offset in .debug_str when adding the tail optimized strings.
+ This is initially the size of .debug_str section in the object,
+ and as unique tail optimized strings are found, this is increased
+ each time. */
+static unsigned int max_strp_off;
+
+/* At the end of read_multifile strp_htab is moved to this variable,
+ which is used to find strings in the shared .debug_str section. */
+static htab_t alt_strp_htab;
+
+/* Structure describing strings in strp_htab. */
+struct strp_entry
+{
+ /* Original .debug_str offset. */
+ unsigned int off;
+ /* New .debug_str offset, or when using strp_{hash,eq}2
+ this is initially iterative hash of the string with the
+ LSB bit used for whether the string has been seen just once
+ or more than once. */
+ unsigned int new_off;
+};
+ALIGN_STRUCT (strp_entry)
+
+/* Hash function in strp_htab used for discovery of tail optimized
+ strings. */
+static hashval_t
+strp_hash (const void *p)
+{
+ struct strp_entry *s = (struct strp_entry *)p;
+
+ return s->off;
+}
+
+/* Corresponding equality function in strp_htab. */
+static int
+strp_eq (const void *p, const void *q)
+{
+ struct strp_entry *s1 = (struct strp_entry *)p;
+ struct strp_entry *s2 = (struct strp_entry *)q;
+
+ return s1->off == s2->off;
+}
+
+/* Hash function in strp_htab used to find what strings are
+ used by more than one object. */
+static hashval_t
+strp_hash2 (const void *p)
+{
+ struct strp_entry *s = (struct strp_entry *)p;
+
+ return s->new_off & ~1U;
+}
+
+/* Corresponding equality function in strp_htab. */
+static int
+strp_eq2 (const void *p, const void *q)
+{
+ struct strp_entry *s1 = (struct strp_entry *)p;
+ struct strp_entry *s2 = (struct strp_entry *)q;
+
+ return strcmp ((char *) debug_sections[DEBUG_STR].data + s1->off,
+ (char *) debug_sections[DEBUG_STR].data + s2->off) == 0;
+}
+
+/* Hash function in strp_htab used from finalize_strp onwards,
+ mapping strings into strings in the new .debug_str section. */
+static hashval_t
+strp_hash3 (const void *p)
+{
+ return hash (p, strlen (p));
+}
+
+/* Corresponding equality function in strp_htab. */
+static int
+strp_eq3 (const void *p, const void *q)
+{
+ return strcmp (p, q) == 0;
+}
+
+/* Called for each DW_FORM_strp offset seen during initial
+ .debug_{info,types,macro} parsing. Before fi_multifile phase
+ this records just tail optimized strings, during fi_multifile
+ it checks whether the string is already in the shared .debug_str
+ section and if not, notes that it will need to be added to the
+ new local .debug_str section. */
+static void
+note_strp_offset (unsigned int off)
+{
+ void **slot;
+ struct strp_entry se;
+
+ if (unlikely (fi_multifile))
+ {
+ unsigned char *p;
+ unsigned int len;
+ hashval_t hash;
+
+ p = debug_sections[DEBUG_STR].data + off;
+ len = strlen ((char *) p);
+ hash = hash (p, len);
+ if (alt_strp_htab)
+ {
+ if (htab_find_with_hash (alt_strp_htab, p, hash))
+ return;
+ }
+ if (strp_htab == NULL)
+ {
+ unsigned int strp_count = debug_sections[DEBUG_STR].size / 64;
+
+ if (strp_count < 100)
+ strp_count = 100;
+ strp_htab = htab_try_create (strp_count, strp_hash2, strp_eq2, NULL);
+ if (strp_htab == NULL)
+ dwz_oom ();
+ }
+
+ se.off = off;
+ se.new_off = hash | 1;
+ slot = htab_find_slot_with_hash (strp_htab, &se, se.new_off & ~1U, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot == NULL)
+ {
+ struct strp_entry *s = pool_alloc (strp_entry, sizeof (*s));
+ *s = se;
+ *slot = (void *) s;
+ }
+ return;
+ }
+ if (off >= debug_sections[DEBUG_STR].size || off == 0)
+ return;
+ if (debug_sections[DEBUG_STR].data[off - 1] == '\0')
+ return;
+ if (strp_htab == NULL)
+ {
+ if (multifile == NULL)
+ return;
+ strp_htab = htab_try_create (50, strp_hash, strp_eq, NULL);
+ if (strp_htab == NULL)
+ dwz_oom ();
+ max_strp_off = debug_sections[DEBUG_STR].size;
+ }
+ se.off = off;
+ slot = htab_find_slot_with_hash (strp_htab, &se, off, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot == NULL)
+ {
+ struct strp_entry *s = pool_alloc (strp_entry, sizeof (*s));
+ s->off = off;
+ s->new_off = max_strp_off;
+ max_strp_off += strlen ((char *) debug_sections[DEBUG_STR].data
+ + off) + 1;
+ if (max_strp_off < s->new_off)
+ {
+ htab_delete (strp_htab);
+ strp_htab = NULL;
+ max_strp_off = 0;
+ multifile = NULL;
+ error (0, 0, ".debug_str too large for multi-file optimization");
+ }
+ *slot = (void *) s;
+ }
+}
+
+/* Map offset in original .debug_str section into
+ offset in new .debug_str, either the shared .debug_str
+ or new local .debug_str. */
+static unsigned
+lookup_strp_offset (unsigned int off)
+{
+ struct strp_entry *s, se;
+
+ if (unlikely (op_multifile || fi_multifile))
+ {
+ unsigned char *p;
+ unsigned int len;
+ hashval_t hash;
+
+ p = debug_sections[DEBUG_STR].data + off;
+ len = strlen ((char *) p);
+ hash = hash (p, len);
+ if (alt_strp_htab)
+ {
+ unsigned char *q = (unsigned char *)
+ htab_find_with_hash (alt_strp_htab, p, hash);
+ if (q != NULL)
+ return q - alt_data[DEBUG_STR];
+ }
+ assert (strp_htab);
+ p = (unsigned char *) htab_find_with_hash (strp_htab, p, hash);
+ assert (p != NULL);
+ return p - debug_sections[DEBUG_STR].new_data;
+ }
+ if (off >= debug_sections[DEBUG_STR].size || off == 0)
+ return off + multi_str_off;
+ if (debug_sections[DEBUG_STR].data[off - 1] == '\0')
+ return off + multi_str_off;
+ se.off = off;
+ s = (struct strp_entry *) htab_find_with_hash (strp_htab, &se, off);
+ return s->new_off + multi_str_off;
+}
+
+/* Note .debug_str offset during write_macro or compute_abbrevs,
+ return either DW_FORM_strp if the string will be in the local
+ .debug_str section, or DW_FORM_strp_sup / DW_FORM_GNU_strp_alt if it
+ will be in the shared .debug_str section. */
+static enum dwarf_form
+note_strp_offset2 (unsigned int off)
+{
+ hashval_t hash;
+ struct strp_entry se;
+ unsigned char *p, *q;
+
+ if (likely (fi_multifile))
+ {
+ unsigned int len;
+
+ if (alt_strp_htab)
+ {
+ p = debug_sections[DEBUG_STR].data + off;
+ len = strlen ((char *) p);
+ hash = hash (p, len);
+ if (htab_find_with_hash (alt_strp_htab, p, hash))
+ return dwarf_5 ? DW_FORM_strp_sup : DW_FORM_GNU_strp_alt;
+ }
+ return DW_FORM_strp;
+ }
+ if (off >= debug_sections[DEBUG_STR].size)
+ return DW_FORM_strp;
+ p = debug_sections[DEBUG_STR].data + off;
+ q = (unsigned char *) strchr ((char *) p, '\0');
+ hash = hash (p, q - p);
+ se.off = off;
+ se.new_off = hash & ~1U;
+ struct strp_entry *s = (struct strp_entry *)
+ htab_find_with_hash (strp_htab, &se, se.new_off);
+ assert (s != NULL);
+ s->new_off |= 1;
+ return DW_FORM_strp;
+}
+
+/* Helper to record all strp_entry entries from strp_htab.
+ Called through htab_traverse. */
+static int
+list_strp_entries (void **slot, void *data)
+{
+ struct strp_entry ***end = (struct strp_entry ***) data;
+ **end = (struct strp_entry *) *slot;
+ (*end)++;
+ return 1;
+}
+
+/* Adapted from bfd/merge.c strrevcmp. */
+static int
+strrevcmp (const void *p, const void *q)
+{
+ struct strp_entry *s1 = *(struct strp_entry **)p;
+ struct strp_entry *s2 = *(struct strp_entry **)q;
+ unsigned int len1 = s1->new_off & ~1U;
+ unsigned int len2 = s2->new_off & ~1U;
+ unsigned int len;
+ unsigned char *p1 = debug_sections[DEBUG_STR].data + s1->off;
+ unsigned char *p2 = debug_sections[DEBUG_STR].data + s2->off;
+
+ if (p1[len1])
+ len1++;
+ if (p2[len2])
+ len2++;
+ p1 += len1;
+ p2 += len2;
+ len = len1;
+ if (len2 < len)
+ len = len2;
+ while (len)
+ {
+ p1--;
+ p2--;
+ if (*p1 != *p2)
+ {
+ if (*p1 < *p2)
+ return -1;
+ return 1;
+ }
+ len--;
+ }
+ if (len1 < len2)
+ return 1;
+ if (len1 > len2)
+ return -1;
+ assert (s1->off == s2->off);
+ return 0;
+}
+
+/* Compute new .debug_str section, from strp_htab content,
+ replace strp_htab hash table with a new one, which maps strings
+ to new .debug_str locations. */
+static unsigned int *
+finalize_strp (bool build_tail_offset_list)
+{
+ unsigned int count, new_count, i, *tail_offset_list = NULL;
+ unsigned int strp_index = 0, tail_offset_list_count = 0, k;
+ struct strp_entry **arr, **end;
+ unsigned char *p;
+
+ if (strp_htab == NULL)
+ {
+ debug_sections[DEBUG_STR].new_data = NULL;
+ debug_sections[DEBUG_STR].new_size = 0;
+ return NULL;
+ }
+ count = htab_elements (strp_htab);
+ arr = (struct strp_entry **)
+ obstack_alloc (&ob, count * sizeof (struct strp_entry *));
+ end = arr;
+ htab_traverse (strp_htab, list_strp_entries, (void *) &end);
+ for (i = 0; i < count; i++)
+ {
+ unsigned int len = strlen ((char *) debug_sections[DEBUG_STR].data
+ + arr[i]->off);
+ arr[i]->new_off = (len & ~1U) | (arr[i]->new_off & 1);
+ }
+ qsort (arr, count, sizeof (struct strp_entry *), strrevcmp);
+ htab_delete (strp_htab);
+ strp_htab = NULL;
+ new_count = count;
+ for (i = 0; i < count; i++)
+ if ((arr[i]->new_off & 1) == 0)
+ {
+ arr[i]->off = -1U;
+ arr[i]->new_off = -1U;
+ new_count--;
+ }
+ else
+ {
+ unsigned int len1, len2, lastlen, j;
+ unsigned char *p1, *p2;
+ len1 = arr[i]->new_off & ~1U;
+ p1 = debug_sections[DEBUG_STR].data + arr[i]->off;
+ if (p1[len1])
+ len1++;
+ lastlen = len1;
+ arr[i]->new_off = strp_index;
+ strp_index += len1 + 1;
+ for (j = i + 1; j < count; j++)
+ {
+ len2 = arr[j]->new_off & ~1U;
+ p2 = debug_sections[DEBUG_STR].data + arr[j]->off;
+ if (p2[len2])
+ len2++;
+ if (len2 >= lastlen)
+ break;
+ if (memcmp (p1 + len1 - len2, p2, len2 + 1) != 0)
+ break;
+ arr[j]->new_off = arr[i]->new_off + len1 - len2;
+ lastlen = len2;
+ tail_offset_list_count++;
+ }
+ i = j - 1;
+ }
+ debug_sections[DEBUG_STR].new_data = malloc (strp_index);
+ if (debug_sections[DEBUG_STR].new_data == NULL)
+ dwz_oom ();
+ debug_sections[DEBUG_STR].new_size = strp_index;
+ strp_htab = htab_try_create (new_count < 32 ? 32 : new_count,
+ strp_hash3, strp_eq3, NULL);
+ if (strp_htab == NULL)
+ dwz_oom ();
+ if (build_tail_offset_list && tail_offset_list_count++ != 0)
+ {
+ tail_offset_list
+ = mmap (NULL, tail_offset_list_count * sizeof (int),
+ PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+ if (tail_offset_list == MAP_FAILED)
+ dwz_oom ();
+ }
+ for (i = 0, k = 0, p = debug_sections[DEBUG_STR].new_data; i < count; i++)
+ if (arr[i]->off == -1U && arr[i]->new_off == -1U)
+ continue;
+ else
+ {
+ unsigned int len = strlen ((char *) debug_sections[DEBUG_STR].data
+ + arr[i]->off) + 1;
+ unsigned int j;
+ void **slot;
+
+ memcpy (p, debug_sections[DEBUG_STR].data + arr[i]->off, len);
+ slot = htab_find_slot_with_hash (strp_htab, p,
+ hash (p, len - 1),
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ assert (*slot == NULL);
+ *slot = (void *) p;
+ for (j = i + 1; j < count; j++)
+ if (arr[j]->new_off >= arr[i]->new_off + len)
+ break;
+ else
+ {
+ unsigned char *q = p + arr[j]->new_off - arr[i]->new_off;
+ unsigned int l = len + arr[i]->new_off - arr[j]->new_off;
+ if (tail_offset_list != NULL)
+ tail_offset_list[k++] = arr[j]->new_off;
+ slot = htab_find_slot_with_hash (strp_htab, q,
+ hash (q, l - 1),
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ assert (*slot == NULL);
+ *slot = (void *) q;
+ }
+ p += len;
+ i = j - 1;
+ }
+ assert (p == debug_sections[DEBUG_STR].new_data + strp_index);
+ if (tail_offset_list != NULL)
+ {
+ tail_offset_list[k++] = 0;
+ assert (k == tail_offset_list_count);
+ }
+ obstack_free (&ob, (void *) arr);
+ return tail_offset_list;
+}
+
+enum mark_refs_mode
+{
+ MARK_REFS_FOLLOW_DUPS = 1,
+ MARK_REFS_RETURN_VAL = 2,
+ MARK_REFS_REFERENCED = 4
+};
+
+/* Mark all DIEs referenced from DIE by setting die_ref_seen to 1,
+ unless already marked. */
+static bool
+mark_refs (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die, int mode)
+{
+ struct abbrev_tag *t;
+ unsigned int i;
+ unsigned char *ptr;
+ dw_die_ref child;
+
+ t = die->die_abbrev;
+ for (i = 0; i < t->nattr; ++i)
+ if (t->attr[i].attr != DW_AT_sibling)
+ switch (t->attr[i].form)
+ {
+ case DW_FORM_ref_addr:
+ if (unlikely (op_multifile))
+ i = -2U;
+ break;
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_indirect:
+ i = -2U;
+ break;
+ }
+ if (i == -1U)
+ {
+ if (unlikely (cu->cu_kind == CU_TYPES))
+ ptr = debug_sections[DEBUG_TYPES].data;
+ else
+ ptr = debug_sections[DEBUG_INFO].data;
+ ptr += die->die_offset;
+ skip_leb128 (ptr);
+ for (i = 0; i < t->nattr; ++i)
+ {
+ uint32_t form = t->attr[i].form;
+ size_t len = 0;
+ uint64_t value;
+ dw_die_ref ref, reft;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ if (unlikely (op_multifile))
+ {
+ value = read_size (ptr, cu->cu_version == 2
+ ? ptr_size : 4);
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ assert (t->attr[i].attr != DW_AT_sibling);
+ ref = off_htab_lookup (cu, value);
+ if ((mode & MARK_REFS_REFERENCED) != 0)
+ ref->die_referenced = 1;
+ goto finish_ref;
+ }
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_addr:
+ ptr += ptr_size;
+ break;
+ case DW_FORM_flag_present:
+ case DW_FORM_implicit_const:
+ break;
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ ++ptr;
+ break;
+ case DW_FORM_data2:
+ ptr += 2;
+ break;
+ case DW_FORM_data4:
+ case DW_FORM_sec_offset:
+ case DW_FORM_strp:
+ case DW_FORM_line_strp:
+ ptr += 4;
+ break;
+ case DW_FORM_data8:
+ case DW_FORM_ref_sig8:
+ ptr += 8;
+ break;
+ case DW_FORM_data16:
+ ptr += 16;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ skip_leb128 (ptr);
+ break;
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ switch (form)
+ {
+ case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+ case DW_FORM_ref1: value = read_8 (ptr); break;
+ case DW_FORM_ref2: value = read_16 (ptr); break;
+ case DW_FORM_ref4: value = read_32 (ptr); break;
+ case DW_FORM_ref8: value = read_64 (ptr); break;
+ default: abort ();
+ }
+ if (t->attr[i].attr == DW_AT_sibling)
+ break;
+ ref = off_htab_lookup (cu, cu->cu_offset + value);
+ if ((mode & MARK_REFS_REFERENCED) != 0)
+ ref->die_referenced = 1;
+ if (!ref->die_collapsed_child
+ && ref->u.p1.die_enter >= top_die->u.p1.die_enter
+ && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+ break;
+ finish_ref:
+ reft = ref;
+ while (!reft->die_root
+ && reft->die_parent->die_tag != DW_TAG_compile_unit
+ && reft->die_parent->die_tag != DW_TAG_partial_unit
+ && !reft->die_parent->die_named_namespace)
+ reft = reft->die_parent;
+ if ((mode & MARK_REFS_FOLLOW_DUPS) && reft->die_dup != NULL)
+ {
+ reft = reft->die_dup;
+ if (die_cu (reft)->cu_kind == CU_PU)
+ break;
+ }
+ if (reft->die_ref_seen == 0)
+ {
+ if ((mode & MARK_REFS_RETURN_VAL))
+ return false;
+ reft->die_ref_seen = 1;
+ mark_refs (die_cu (reft), reft, reft, mode);
+ }
+ break;
+ case DW_FORM_string:
+ ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ case DW_FORM_block1:
+ len = *ptr++;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block:
+ case DW_FORM_exprloc:
+ len = read_uleb128 (ptr);
+ form = DW_FORM_block1;
+ break;
+ default:
+ abort ();
+ }
+
+ if (form == DW_FORM_block1)
+ ptr += len;
+ }
+ }
+
+ for (child = die->die_child; child; child = child->die_sib)
+ if (!mark_refs (cu, top_die, child, mode))
+ return false;
+ return true;
+}
+
+/* Remove completely unneeded children of DIE and remove unreferenced DIEs
+ from offset hash tables. */
+static void
+remove_dies (dw_cu_ref cu, dw_die_ref die, bool remove)
+{
+ dw_die_ref child, next;
+ if (die->die_toplevel && die->die_ref_seen == 0 && !low_mem)
+ remove = true;
+ for (child = die->die_child; child; child = next)
+ {
+ next = child->die_sib;
+ remove_dies (cu, child, remove);
+ }
+ if (die->die_referenced == 0)
+ {
+ htab_t h = cu->cu_kind == CU_TYPES ? types_off_htab : off_htab;
+ void **slot = htab_find_slot_with_hash (h, die, off_hash (die),
+ NO_INSERT);
+ if (slot != NULL)
+ htab_clear_slot (h, slot);
+ }
+ if (!remove)
+ return;
+ if (die->die_toplevel == 0)
+ {
+ memset (die, '\0', offsetof (struct dw_die, die_dup));
+ die->die_sib = die_nontoplevel_freelist;
+ die_nontoplevel_freelist = die;
+ }
+ else
+ die->die_child = NULL;
+}
+
+/* Remove unneeded children DIEs. During phase 0 die_ref_seen
+ of toplevel DIEs is computed, during phase 1 mark_refs is called
+ to find referenced DIEs, during phase 2 unneeded children DIEs
+ are removed. */
+static void
+remove_unneeded (dw_cu_ref cu, dw_die_ref die, unsigned int phase)
+{
+ dw_die_ref child;
+ for (child = die->die_child; child; child = child->die_sib)
+ {
+ if (child->die_named_namespace)
+ {
+ remove_unneeded (cu, child, phase);
+ if (phase == 2)
+ child->die_ref_seen = 0;
+ }
+ else
+ switch (phase)
+ {
+ case 0:
+ child->die_ref_seen = child->die_dup == NULL;
+ break;
+ case 1:
+ if (child->die_dup == NULL || low_mem)
+ mark_refs (cu, child, child, MARK_REFS_REFERENCED);
+ break;
+ case 2:
+ remove_dies (cu, child, false);
+ child->die_ref_seen = 0;
+ break;
+ }
+ }
+}
+
+/* Entries in meta_abbrev_htab, mapping .debug_abbrev section offsets
+ to abbrev hash tables. */
+struct meta_abbrev_entry
+{
+ /* .debug_abbrev offset. */
+ unsigned int abbrev_off;
+ /* Corresponding hash table. */
+ htab_t abbrev_htab;
+};
+
+/* Hash table for mapping of .debug_abbrev section offsets to
+ abbrev hash tables. */
+static htab_t meta_abbrev_htab;
+/* Dummy entry used during OOM handling. */
+static struct meta_abbrev_entry meta_abbrev_fallback;
+
+/* Hash function for meta_abbrev_htab. */
+static hashval_t
+meta_abbrev_hash (const void *p)
+{
+ struct meta_abbrev_entry *m = (struct meta_abbrev_entry *)p;
+
+ return m->abbrev_off;
+}
+
+/* Equality function for meta_abbrev_htab. */
+static int
+meta_abbrev_eq (const void *p, const void *q)
+{
+ struct meta_abbrev_entry *m1 = (struct meta_abbrev_entry *)p;
+ struct meta_abbrev_entry *m2 = (struct meta_abbrev_entry *)q;
+
+ return m1->abbrev_off == m2->abbrev_off;
+}
+
+/* Delete function for meta_abbrev_htab. */
+static void
+meta_abbrev_del (void *p)
+{
+ struct meta_abbrev_entry *m = (struct meta_abbrev_entry *)p;
+
+ if (m->abbrev_htab != NULL)
+ htab_delete (m->abbrev_htab);
+}
+
+/* Collapse children of TOP_DIE to decrease memory usage. */
+static void
+collapse_child (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die,
+ unsigned int *tick)
+{
+ dw_die_ref child, next;
+ bool has_children = die->die_child != NULL;
+ unsigned int tick_diff = *tick;
+ for (child = die->die_child; child; child = next)
+ {
+ next = child->die_sib;
+ (*tick)++;
+ collapse_child (cu, top_die, child, tick);
+ }
+ if (has_children)
+ (*tick)++;
+ if (top_die == die)
+ {
+ die->die_child = NULL;
+ die->die_collapsed_children = 1;
+ }
+ else if (die->die_referenced)
+ {
+ die->die_parent = top_die;
+ if (tick_diff <= 0xffff && !die->die_intercu_referenced)
+ {
+ dw_die_ref ref;
+ void **slot;
+ if (die_collapsed_child_freelist)
+ {
+ ref = die_collapsed_child_freelist;
+ die_collapsed_child_freelist = ref->die_parent;
+ }
+ else
+ ref = pool_alloc (dw_die, offsetof (struct dw_die, die_child));
+ memcpy (ref, die, offsetof (struct dw_die, die_child));
+ ref->die_collapsed_child = 1;
+ ref->die_tag = tick_diff;
+ slot = htab_find_slot_with_hash (cu->cu_kind == CU_TYPES
+ ? types_off_htab : off_htab,
+ ref, off_hash (ref), NO_INSERT);
+ assert (slot != NULL);
+ *slot = (void *) ref;
+ memset (die, '\0', offsetof (struct dw_die, die_dup));
+ die->die_sib = die_nontoplevel_freelist;
+ die_nontoplevel_freelist = die;
+ }
+ else
+ {
+ die->die_child = NULL;
+ die->die_sib = NULL;
+ die->die_ref_seen = tick_diff;
+ }
+ }
+ else
+ {
+ memset (die, '\0', offsetof (struct dw_die, die_dup));
+ die->die_sib = die_nontoplevel_freelist;
+ die_nontoplevel_freelist = die;
+ }
+}
+
+/* Collapse children of all toplevel DIEs that can be collapsed. */
+static void
+collapse_children (dw_cu_ref cu, dw_die_ref die)
+{
+ dw_die_ref child;
+ for (child = die->die_child; child; child = child->die_sib)
+ if (child->die_named_namespace)
+ collapse_children (cu, child);
+ else if (child->die_child == NULL)
+ continue;
+ else if (child->die_nextdup == NULL
+ || (child->die_dup != NULL
+ && (die_cu (child->die_dup)->cu_kind != CU_PU
+ || child->die_dup->die_nextdup != child)))
+ {
+ unsigned int tick = 0;
+ collapse_child (cu, child, child, &tick);
+ }
+}
+
+/* Count the number of DIEs in the .debug_info section, and see if we run into
+ some limit. */
+static int
+try_debug_info (DSO *dso)
+{
+ unsigned char *ptr, *endcu, *endsec;
+ unsigned int value;
+ htab_t abbrev = NULL;
+ unsigned int last_abbrev_offset = 0;
+ struct abbrev_tag tag, *t;
+ unsigned int ndies;
+ unsigned ret = 1;
+ int kind = DEBUG_INFO;
+ bool low_mem_die_limit_hit = false;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "try_debug_info\n");
+ }
+
+ if (tracing)
+ fprintf (stderr, "Counting DIEs\n");
+
+ ndies = 0;
+ ptr = debug_sections[kind].data;
+ endsec = ptr + debug_sections[kind].size;
+ while (ptr < endsec)
+ {
+ unsigned int culen;
+ int cu_version;
+
+ /* Note header is one bigger with DWARF version 5. */
+ if (ptr + (kind == DEBUG_TYPES ? 23 : 11) > endsec)
+ {
+ error (0, 0, "%s: %s CU header too small", dso->filename,
+ debug_sections[kind].name);
+ goto fail;
+ }
+
+ endcu = ptr + 4;
+ culen = read_32 (ptr);
+ if (culen >= 0xfffffff0)
+ {
+ error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+ goto fail;
+ }
+ endcu += culen;
+
+ if (endcu > endsec)
+ {
+ error (0, 0, "%s: %s too small", dso->filename,
+ debug_sections[kind].name);
+ goto fail;
+ }
+
+ cu_version = read_16 (ptr);
+ if (kind == DEBUG_TYPES && (cu_version < 2 || cu_version > 4))
+ {
+ error (0, 0, "%s: DWARF version %d in .debug_types unhandled",
+ dso->filename, cu_version);
+ goto fail;
+ }
+ else if (cu_version < 2 || cu_version > 5)
+ {
+ error (0, 0, "%s: DWARF version %d in .debug_info unhandled",
+ dso->filename, cu_version);
+ goto fail;
+ }
+
+ if (cu_version == 5)
+ {
+ value = read_8 (ptr);
+ if (value != DW_UT_compile && value != DW_UT_partial)
+ error (0, 0, "%s: DWARF CU type %s unhandled", dso->filename,
+ get_DW_UT_str (value));
+ }
+ else
+ {
+ value = read_32 (ptr);
+ if (value >= debug_sections[DEBUG_ABBREV].size)
+ {
+ if (debug_sections[DEBUG_ABBREV].data == NULL)
+ error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+ else
+ error (0, 0, "%s: DWARF CU abbrev offset too large",
+ dso->filename);
+ goto fail;
+ }
+ }
+
+ if (ptr_size == 0)
+ {
+ ptr_size = read_8 (ptr);
+ if (ptr_size != 4 && ptr_size != 8)
+ {
+ error (0, 0, "%s: Invalid DWARF pointer size %d",
+ dso->filename, ptr_size);
+ goto fail;
+ }
+ }
+ else if (read_8 (ptr) != ptr_size)
+ {
+ error (0, 0, "%s: DWARF pointer size differs between CUs",
+ dso->filename);
+ goto fail;
+ }
+
+ if (cu_version == 5)
+ {
+ /* Above we only checked for the smaller version 4 header size. */
+ if (ptr + 4 > endsec)
+ {
+ error (0, 0, "%s: %s CU version 5 header too small",
+ dso->filename, debug_sections[kind].name);
+ goto fail;
+ }
+ value = read_32 (ptr);
+ if (value >= debug_sections[DEBUG_ABBREV].size)
+ {
+ if (debug_sections[DEBUG_ABBREV].data == NULL)
+ error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+ else
+ error (0, 0, "%s: DWARF CU abbrev offset too large",
+ dso->filename);
+ goto fail;
+ }
+ }
+
+ if (abbrev == NULL || value != last_abbrev_offset)
+ {
+ if (abbrev)
+ htab_delete (abbrev);
+ abbrev
+ = read_abbrev (dso, debug_sections[DEBUG_ABBREV].data + value);
+ if (abbrev == NULL)
+ {
+ error (0, 0, "%s: Couldn't read abbrev at offset 0x%x",
+ dso->filename, value);
+ goto fail;
+ }
+ }
+ last_abbrev_offset = value;
+
+ while (ptr < endcu)
+ {
+ tag.entry = read_uleb128 (ptr);
+ if (tag.entry == 0)
+ continue;
+ if (ndies == max_die_limit)
+ {
+ error (0, 0, "%s: Too many DIEs, not optimizing",
+ dso->filename);
+ goto fail;
+ }
+ /* If we reach the DIE limit, signal the dwz caller that it
+ should retry with low_mem. */
+ if (likely (!low_mem) && ndies == low_mem_die_limit)
+ {
+ if (tracing)
+ fprintf (stderr, "Hit low-mem die-limit\n");
+ if (estimate_nr_dies () > max_die_limit)
+ /* Keep going, we still might hit the max die-limit. */
+ low_mem_die_limit_hit = true;
+ else
+ {
+ ret = 2;
+ goto fail;
+ }
+ }
+ ndies++;
+ t = htab_find_with_hash (abbrev, &tag, tag.entry);
+ if (t == NULL)
+ {
+ error (0, 0, "%s: Could not find DWARF abbreviation %d",
+ dso->filename, tag.entry);
+ goto fail;
+ }
+ ptr = skip_attrs_1 (cu_version, t, ptr);
+ }
+ }
+
+ if (low_mem_die_limit_hit)
+ ret = 2;
+ else
+ ret = 0;
+
+ fail:
+ if (abbrev)
+ htab_delete (abbrev);
+
+ return ret;
+}
+
+/* Read language attribute encoded using FORM from location PTR, return
+ pointer to location after the attribute. Assign the attribute value
+ to *LANG. */
+static unsigned char *
+read_lang (unsigned char *ptr, enum dwarf_form form,
+ enum dwarf_source_language *lang)
+{
+ bool error_p = false;
+ *lang = read_u16 (ptr, form, error_p);
+ if (unlikely (error_p))
+ {
+ *lang = 0;
+ error (0, 0, "Invalid DW_AT_language attribute, ignoring");
+ }
+ return ptr;
+}
+
+/* First phase of the DWARF compression. Parse .debug_info section
+ (for kind == DEBUG_INFO) or .debug_types section (for kind == DEBUG_TYPES)
+ for each CU in it construct internal representation for the CU
+ and its DIE tree, compute checksums of DIEs and look for duplicates. */
+static int
+read_debug_info (DSO *dso, int kind, unsigned int *die_count)
+{
+ unsigned char *ptr, *endcu, *endsec;
+ unsigned int value;
+ htab_t abbrev = NULL;
+ unsigned int last_abbrev_offset = 0;
+ unsigned int last_debug_line_off = 0;
+ struct dw_file *cu_files = NULL;
+ unsigned int cu_nfiles = 0;
+ bool note_strp_forms = multifile != NULL && !op_multifile
+ && !rd_multifile && !low_mem;
+ struct abbrev_tag tag, *t;
+ unsigned int cu_chunk = 0;
+ dw_cu_ref cu_tail = NULL, cu_collapse = NULL;
+ unsigned int cu_kind = rd_multifile ? CU_ALT
+ : kind == DEBUG_TYPES ? CU_TYPES : CU_NORMAL;
+ void *to_free = NULL;
+ int ret = 1;
+ unsigned int ndies;
+ bool low_mem_phase1 = low_mem && kind == DEBUG_INFO;
+ struct dw_cu cu_buf;
+ struct dw_die die_buf;
+ bool lang_p = odr || uni_lang_p;
+
+ odr_active_p = false;
+ if (odr)
+ odr_phase = 1;
+
+ unsigned int estimated_nr_dies = estimate_nr_dies ();
+ if (kind == DEBUG_INFO
+ && multifile_mode == 0
+ && die_count_method == estimate)
+ {
+ bool do_count = (estimated_nr_dies > max_die_limit
+ || estimated_nr_dies > low_mem_die_limit);
+ if (tracing)
+ fprintf (stderr, "Using die count estimate %u to decide whether to"
+ " count DIEs: %s\n", estimated_nr_dies,
+ do_count ? "yes" : "no");
+ if (do_count)
+ {
+ int try_ret = try_debug_info (dso);
+ if (try_ret != 0)
+ return try_ret;
+ }
+ }
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "read_debug_info %s%s\n",
+ kind == DEBUG_INFO ? ".debug_info" : ".debug_types",
+ low_mem && kind == DEBUG_INFO ? " (low-mem)" : "");
+ }
+
+ if (likely (!fi_multifile && kind != DEBUG_TYPES))
+ {
+ dup_htab = htab_try_create (100000, die_hash, die_eq, NULL);
+ if (dup_htab == NULL)
+ dwz_oom ();
+ }
+ if (unlikely (meta_abbrev_htab == NULL
+ && (op_multifile || rd_multifile || fi_multifile || low_mem)))
+ {
+ meta_abbrev_htab
+ = htab_try_create (500, meta_abbrev_hash, meta_abbrev_eq,
+ meta_abbrev_del);
+ if (meta_abbrev_htab == NULL)
+ dwz_oom ();
+ to_free = obstack_alloc (&ob2, 1);
+ }
+
+ low_mem_phase2:
+ ndies = 0;
+ ptr = debug_sections[kind].data;
+ endsec = ptr + debug_sections[kind].size;
+ while (ptr < endsec)
+ {
+ unsigned int cu_offset = ptr - debug_sections[kind].data;
+ unsigned int tick = 0, culen;
+ int cu_version;
+ dw_cu_ref cu;
+ dw_die_ref *diep, parent, die;
+ bool present;
+ unsigned int debug_line_off;
+ unsigned int type_offset = 0;
+
+ /* Note header is one bigger with DWARF version 5. */
+ if (ptr + (kind == DEBUG_TYPES ? 23 : 11) > endsec)
+ {
+ error (0, 0, "%s: %s CU header too small", dso->filename,
+ debug_sections[kind].name);
+ goto fail;
+ }
+
+ endcu = ptr + 4;
+ culen = read_32 (ptr);
+ if (culen >= 0xfffffff0)
+ {
+ error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+ goto fail;
+ }
+ endcu += culen;
+
+ if (endcu > endsec)
+ {
+ error (0, 0, "%s: %s too small", dso->filename,
+ debug_sections[kind].name);
+ goto fail;
+ }
+
+ cu_version = read_16 (ptr);
+ if (kind == DEBUG_TYPES && (cu_version < 2 || cu_version > 4))
+ {
+ error (0, 0, "%s: DWARF version %d in .debug_types unhandled",
+ dso->filename, cu_version);
+ goto fail;
+ }
+ else if (cu_version < 2 || cu_version > 5)
+ {
+ error (0, 0, "%s: DWARF version %d in .debug_info unhandled",
+ dso->filename, cu_version);
+ goto fail;
+ }
+
+ if (cu_version == 5)
+ {
+ value = read_8 (ptr);
+ if (value != DW_UT_compile && value != DW_UT_partial)
+ {
+ error (0, 0, "%s: DWARF CU type %s unhandled", dso->filename,
+ get_DW_UT_str (value));
+ goto fail;
+ }
+ }
+ else
+ {
+ value = read_32 (ptr);
+ if (value >= debug_sections[DEBUG_ABBREV].size)
+ {
+ if (debug_sections[DEBUG_ABBREV].data == NULL)
+ error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+ else
+ error (0, 0, "%s: DWARF CU abbrev offset too large",
+ dso->filename);
+ goto fail;
+ }
+ }
+
+ if (ptr_size == 0)
+ {
+ ptr_size = read_8 (ptr);
+ if (ptr_size != 4 && ptr_size != 8)
+ {
+ error (0, 0, "%s: Invalid DWARF pointer size %d",
+ dso->filename, ptr_size);
+ goto fail;
+ }
+ }
+ else if (read_8 (ptr) != ptr_size)
+ {
+ error (0, 0, "%s: DWARF pointer size differs between CUs",
+ dso->filename);
+ goto fail;
+ }
+
+ if (cu_version == 5)
+ {
+ /* Above we only checked for the smaller version 4 header size. */
+ if (ptr + 4 > endsec)
+ {
+ error (0, 0, "%s: %s CU version 5 header too small",
+ dso->filename, debug_sections[kind].name);
+ goto fail;
+ }
+ value = read_32 (ptr);
+ if (value >= debug_sections[DEBUG_ABBREV].size)
+ {
+ if (debug_sections[DEBUG_ABBREV].data == NULL)
+ error (0, 0, "%s: .debug_abbrev not present", dso->filename);
+ else
+ error (0, 0, "%s: DWARF CU abbrev offset too large",
+ dso->filename);
+ goto fail;
+ }
+ }
+
+ if (unlikely (op_multifile))
+ {
+ if (ptr == endcu)
+ {
+ dw_cu_ref cuf = cu_tail ? cu_tail->cu_next : first_cu;
+ /* Inside of optimize_multifile, DIE hashes are computed
+ only after all the CUs from a particular DSO or
+ executable have been parsed, as we follow
+ DW_FORM_ref_addr then. */
+ for (cu = cuf; cu; cu = cu->cu_next)
+ if (checksum_die (dso, cu, NULL, cu->cu_die))
+ goto fail;
+
+ for (cu = cuf; cu; cu = cu->cu_next)
+ checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+
+ if (dump_dies_p)
+ for (cu = cuf; cu; cu = cu->cu_next)
+ dump_dies (0, cu->cu_die);
+
+ for (cu = cuf; cu; cu = cu->cu_next)
+ if (find_dups (cu->cu_die))
+ goto fail;
+
+ for (cu = cuf; cu; cu = cu->cu_next)
+ remove_unneeded (cu, cu->cu_die, 0);
+ for (cu = cuf; cu; cu = cu->cu_next)
+ remove_unneeded (cu, cu->cu_die, 1);
+ for (cu = cuf; cu; cu = cu->cu_next)
+ remove_unneeded (cu, cu->cu_die, 2);
+
+ if (cu_collapse == NULL)
+ cu_collapse = first_cu;
+ while (cu_collapse->cu_chunk < cu_chunk)
+ {
+ collapse_children (cu_collapse, cu_collapse->cu_die);
+ cu_collapse = cu_collapse->cu_next;
+ }
+
+ cu_tail = last_cu;
+ cu_chunk++;
+ continue;
+ }
+ }
+ else
+ cu_chunk++;
+
+ if (unlikely (meta_abbrev_htab != NULL))
+ {
+ struct meta_abbrev_entry m, *mp;
+ void **slot;
+ m.abbrev_off = value;
+ slot = htab_find_slot_with_hash (meta_abbrev_htab, &m,
+ m.abbrev_off, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ else if (*slot != NULL)
+ abbrev = ((struct meta_abbrev_entry *) *slot)->abbrev_htab;
+ else
+ {
+ *slot = (void *) &meta_abbrev_fallback;
+ abbrev
+ = read_abbrev (dso, debug_sections[DEBUG_ABBREV].data + value);
+ if (abbrev == NULL)
+ goto fail;
+ mp = (struct meta_abbrev_entry *)
+ obstack_alloc (&ob2, sizeof (*mp));
+ mp->abbrev_off = value;
+ mp->abbrev_htab = abbrev;
+ *slot = (void *) mp;
+ }
+ }
+ else if (abbrev == NULL || value != last_abbrev_offset)
+ {
+ if (abbrev)
+ htab_delete (abbrev);
+ abbrev
+ = read_abbrev (dso, debug_sections[DEBUG_ABBREV].data + value);
+ if (abbrev == NULL)
+ {
+ error (0, 0, "%s: Couldn't read abbrev at offset 0x%x",
+ dso->filename, value);
+
+ goto fail;
+ }
+ }
+ last_abbrev_offset = value;
+
+ if (unlikely (kind == DEBUG_TYPES))
+ {
+ ptr += 8;
+ type_offset = read_32 (ptr);
+ }
+
+ if (unlikely (low_mem_phase1))
+ cu = &cu_buf;
+ else
+ cu = pool_alloc (dw_cu, sizeof (struct dw_cu));
+ memset (cu, '\0', sizeof (*cu));
+ cu->cu_kind = cu_kind;
+ cu->cu_offset = cu_offset;
+ cu->cu_version = cu_version;
+ cu->cu_chunk = cu_chunk;
+ if (unlikely (op_multifile || low_mem))
+ cu->cu_abbrev = abbrev;
+ diep = &cu->cu_die;
+ parent = NULL;
+ if (unlikely (low_mem_phase1))
+ ;
+ else if (first_cu == NULL)
+ first_cu = last_cu = cu;
+ else
+ {
+ last_cu->cu_next = cu;
+ last_cu = cu;
+ }
+
+ while (ptr < endcu)
+ {
+ unsigned int i;
+ unsigned int die_offset = ptr - debug_sections[kind].data;
+
+ tag.entry = read_uleb128 (ptr);
+ if (tag.entry == 0)
+ {
+ if (unlikely (low_mem_phase1))
+ continue;
+ if (parent)
+ {
+ diep = &parent->die_sib;
+ parent->u.p1.die_exit = tick++;
+ if (parent->die_root == 0)
+ parent = parent->die_parent;
+ else
+ parent = NULL;
+ }
+ else
+ diep = NULL;
+ continue;
+ }
+ if (diep == NULL)
+ {
+ error (0, 0, "%s: Wrong %s DIE tree", dso->filename,
+ debug_sections[kind].name);
+ goto fail;
+ }
+ t = htab_find_with_hash (abbrev, &tag, tag.entry);
+ if (t == NULL)
+ {
+ error (0, 0, "%s: Could not find DWARF abbreviation %d",
+ dso->filename, tag.entry);
+ goto fail;
+ }
+ if (likely (!op_multifile && !rd_multifile && !fi_multifile)
+ && likely (kind == DEBUG_INFO))
+ {
+ if (ndies == max_die_limit)
+ {
+ error (0, 0, "%s: Too many DIEs, not optimizing",
+ dso->filename);
+ goto fail;
+ }
+ /* If we reach the DIE limit, silently signal the dwz
+ caller that it should retry with low_mem. */
+ if (likely (!low_mem) && ndies == low_mem_die_limit)
+ {
+ if (tracing)
+ fprintf (stderr, "Hit low-mem die-limit\n");
+ ret = 2;
+ goto fail;
+ }
+ }
+ ndies++;
+ if (unlikely (low_mem_phase1))
+ die = &die_buf;
+ else if (parent == NULL
+ || parent->die_root
+ || parent->die_named_namespace)
+ {
+ die = pool_alloc (dw_die, sizeof (struct dw_die));
+ memset (die, '\0', sizeof (struct dw_die));
+ die->die_toplevel = 1;
+ }
+ else
+ {
+ if (die_nontoplevel_freelist)
+ {
+ die = die_nontoplevel_freelist;
+ die_nontoplevel_freelist = die->die_sib;
+ }
+ else
+ die = pool_alloc (dw_die, offsetof (struct dw_die, die_dup));
+ memset (die, '\0', offsetof (struct dw_die, die_dup));
+ }
+ *diep = die;
+ die->die_tag = t->tag;
+ die->die_abbrev = t;
+ die->die_offset = die_offset;
+ if (parent)
+ die->die_parent = parent;
+ else
+ {
+ die->die_root = 1;
+ die->die_parent = (dw_die_ref) cu;
+ }
+ die->u.p1.die_enter = tick;
+ die->u.p1.die_exit = tick++;
+ if (likely (!low_mem_phase1))
+ {
+ if (t->children)
+ {
+ diep = &die->die_child;
+ parent = die;
+ }
+ else
+ diep = &die->die_sib;
+ }
+ for (i = 0; i < t->nattr; ++i)
+ {
+ uint32_t form = t->attr[i].form;
+ size_t len = 0;
+
+ while (form == DW_FORM_indirect)
+ {
+ form = read_uleb128 (ptr);
+ if (ptr > endcu)
+ {
+ error (0, 0, "%s: Attributes extend beyond end of CU",
+ dso->filename);
+ goto fail;
+ }
+ }
+
+ /* Get length of expr/blocks first. Canonicalize all,
+ except exprloc, to DW_FORM_block1. */
+ switch (form)
+ {
+ case DW_FORM_block1:
+ len = *ptr++;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block:
+ len = read_uleb128 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_exprloc:
+ len = read_uleb128 (ptr);
+ break;
+ default:
+ break;
+ }
+
+ if (unlikely (low_mem_phase1)
+ && add_locexpr_dummy_dies (dso, cu, die, ptr, form,
+ t->attr[i].attr, len))
+ goto fail;
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ if (unlikely (low_mem_phase1))
+ {
+ unsigned int offset
+ = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+ add_dummy_die (cu, offset);
+ }
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_addr:
+ ptr += ptr_size;
+ break;
+ case DW_FORM_flag_present:
+ break;
+ case DW_FORM_implicit_const:
+ if (lang_p
+ && (die->die_tag == DW_TAG_compile_unit
+ || die->die_tag == DW_TAG_partial_unit)
+ && t->attr[i].attr == DW_AT_language)
+ cu->lang = t->values[i];
+ break;
+ case DW_FORM_data1:
+ if (lang_p
+ && (die->die_tag == DW_TAG_compile_unit
+ || die->die_tag == DW_TAG_partial_unit)
+ && t->attr[i].attr == DW_AT_language)
+ cu->lang = *ptr;
+ /* FALLTHRU */
+ case DW_FORM_ref1:
+ case DW_FORM_flag:
+ ++ptr;
+ break;
+ case DW_FORM_data2:
+ if (lang_p
+ && (die->die_tag == DW_TAG_compile_unit
+ || die->die_tag == DW_TAG_partial_unit)
+ && t->attr[i].attr == DW_AT_language)
+ cu->lang = do_read_16 (ptr);
+ /* FALLTHRU */
+ case DW_FORM_ref2:
+ ptr += 2;
+ break;
+ case DW_FORM_data4:
+ if (lang_p
+ && (die->die_tag == DW_TAG_compile_unit
+ || die->die_tag == DW_TAG_partial_unit)
+ && t->attr[i].attr == DW_AT_language)
+ read_lang (ptr, form, &cu->lang);
+ /* FALLTHRU */
+ case DW_FORM_ref4:
+ case DW_FORM_sec_offset:
+ ptr += 4;
+ break;
+ case DW_FORM_data8:
+ if (lang_p
+ && (die->die_tag == DW_TAG_compile_unit
+ || die->die_tag == DW_TAG_partial_unit)
+ && t->attr[i].attr == DW_AT_language)
+ read_lang (ptr, form, &cu->lang);
+ /* FALLTHRU */
+ case DW_FORM_ref8:
+ case DW_FORM_ref_sig8:
+ ptr += 8;
+ break;
+ case DW_FORM_data16:
+ ptr += 16;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ if (lang_p
+ && (die->die_tag == DW_TAG_compile_unit
+ || die->die_tag == DW_TAG_partial_unit)
+ && t->attr[i].attr == DW_AT_language)
+ {
+ ptr = read_lang (ptr, form, &cu->lang);
+ break;
+ }
+ /* FALLTHRU */
+ case DW_FORM_ref_udata:
+ skip_leb128 (ptr);
+ break;
+ case DW_FORM_strp:
+ if (t->attr[i].attr == DW_AT_name
+ && (die->die_tag == DW_TAG_namespace
+ || die->die_tag == DW_TAG_module)
+ && !die->die_root
+ && (die->die_parent->die_root
+ || die->die_parent->die_named_namespace))
+ die->die_named_namespace = 1;
+ if (note_strp_forms)
+ note_strp_offset (read_32 (ptr));
+ else
+ ptr += 4;
+ break;
+ case DW_FORM_line_strp:
+ if (t->attr[i].attr == DW_AT_name
+ && (die->die_tag == DW_TAG_namespace
+ || die->die_tag == DW_TAG_module)
+ && !die->die_root
+ && (die->die_parent->die_root
+ || die->die_parent->die_named_namespace))
+ die->die_named_namespace = 1;
+ /* Don't note strp, different string table. */
+ ptr += 4;
+ break;
+ case DW_FORM_string:
+ ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+ if (t->attr[i].attr == DW_AT_name
+ && (die->die_tag == DW_TAG_namespace
+ || die->die_tag == DW_TAG_module)
+ && !die->die_root
+ && (die->die_parent->die_root
+ || die->die_parent->die_named_namespace))
+ die->die_named_namespace = 1;
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ /* All expr/blocks lengths already handled above.
+ Just canonicalize exprloc to block1 too. */
+ case DW_FORM_exprloc:
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block1:
+ break;
+ case DW_FORM_block2:
+ case DW_FORM_block4:
+ case DW_FORM_block:
+ abort ();
+ default:
+ error (0, 0, "%s: Unknown DWARF %s at DIE [%x]",
+ dso->filename, get_DW_FORM_str (form), die_offset);
+ goto fail;
+ }
+
+ if (ptr > endcu)
+ {
+ error (0, 0, "%s: Attributes extend beyond end of CU "
+ "for DIE [%x]",
+ dso->filename, die_offset);
+ goto fail;
+ }
+
+ if (form == DW_FORM_block1)
+ {
+ if (len >= (size_t) (endcu - ptr))
+ {
+ error (0, 0, "%s: Attributes extend beyond end of CU "
+ "for DIE [%x]",
+ dso->filename, die_offset);
+ goto fail;
+ }
+
+ if (t->attr[i].attr > DW_AT_loclists_base
+ && (t->attr[i].attr < DW_AT_MIPS_fde
+ || t->attr[i].attr > DW_AT_MIPS_has_inlines)
+ && (t->attr[i].attr < DW_AT_sf_names
+ || t->attr[i].attr > DW_AT_body_end)
+ && (t->attr[i].attr < DW_AT_GNU_call_site_value
+ || t->attr[i].attr
+ > DW_AT_GNU_call_site_target_clobbered))
+ {
+ error (0, 0, "%s: Unknown DWARF %s with "
+ "block DW_FORM for DIE [%x]",
+ dso->filename, get_DW_AT_str (t->attr[i].attr),
+ die_offset);
+ goto fail;
+ }
+
+ ptr += len;
+ }
+ }
+ die->die_size = (ptr - debug_sections[kind].data)
+ - die_offset;
+ if (unlikely (low_mem))
+ {
+ if (low_mem_phase1)
+ continue;
+ if (off_htab != NULL && kind == DEBUG_INFO)
+ {
+ void **slot
+ = htab_find_slot_with_hash (off_htab, die, off_hash (die),
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot != NULL)
+ {
+ dw_die_ref ref = (dw_die_ref) *slot;
+ assert (ref->die_collapsed_child);
+ die->die_referenced = 1;
+ die->die_intercu_referenced = 1;
+ memset (ref, '\0', offsetof (struct dw_die, die_child));
+ ref->die_parent = die_collapsed_child_freelist;
+ die_collapsed_child_freelist = ref;
+ }
+ *slot = (void *) die;
+ continue;
+ }
+ }
+
+ off_htab_add_die (cu, die, die_count);
+ }
+
+ if (unlikely (low_mem_phase1))
+ continue;
+
+ if (cu->cu_die == NULL
+ || (cu->cu_die->die_tag != DW_TAG_compile_unit
+ && cu->cu_die->die_tag != DW_TAG_partial_unit
+ && cu->cu_die->die_tag != DW_TAG_type_unit)
+ || cu->cu_die->die_sib != NULL)
+ {
+ error (0, 0, "%s: %s section chunk doesn't contain a single"
+ " compile_unit or partial_unit", dso->filename,
+ debug_sections[kind].name);
+ goto fail;
+ }
+
+ cu->cu_comp_dir = get_AT_string (cu->cu_die, DW_AT_comp_dir);
+ if (skip_producers_p
+ && skip_producer (get_AT_string (cu->cu_die, DW_AT_producer)))
+ {
+ cu->cu_die->die_remove = 1;
+ continue;
+ }
+ enum dwarf_form form;
+ debug_line_off
+ = get_AT_int (cu->cu_die, DW_AT_stmt_list, &present, &form);
+ if (present)
+ {
+ if (!(form == DW_FORM_sec_offset || form == DW_FORM_data4))
+ {
+ error (0, 0, "%s: DW_AT_stmt_list not DW_FORM_sec_offset or"
+ " DW_FORM_data4", dso->filename);
+ goto fail;
+ }
+
+ if (cu_files != NULL && last_debug_line_off == debug_line_off)
+ {
+ cu->cu_nfiles = cu_nfiles;
+ cu->cu_files = cu_files;
+ }
+ else
+ {
+ if (read_debug_line (dso, cu, debug_line_off))
+ goto fail;
+ cu_nfiles = cu->cu_nfiles;
+ cu_files = cu->cu_files;
+ last_debug_line_off = debug_line_off;
+ }
+ }
+
+ if (likely (!op_multifile && !rd_multifile && !fi_multifile)
+ && likely (kind == DEBUG_INFO))
+ {
+ if (checksum_die (dso, cu, NULL, cu->cu_die))
+ goto fail;
+ checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+ if (odr)
+ {
+ dw_die_ref die;
+ FOREACH_LOW_TOPLEVEL_DIE_IN_CU (die, cu)
+ {
+ if (die->die_ck_state != CK_KNOWN)
+ continue;
+ if (die_odr_state (die) != ODR_NONE)
+ die->u.p1.die_ref_hash = die->u.p1.die_hash;
+ else
+ die->die_ref_hash_computed = 0;
+ }
+ checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+ }
+
+ if (dump_dies_p)
+ dump_dies (0, cu->cu_die);
+
+ if (find_dups (cu->cu_die))
+ goto fail;
+ }
+ if (unlikely (kind == DEBUG_TYPES))
+ {
+ dw_die_ref ref = off_htab_lookup (cu, cu->cu_offset + type_offset);
+ if (ref == NULL)
+ {
+ error (0, 0, "%s: Couldn't find DIE at [%x] "
+ "referenced by type_offset from cu DIE at [%x]",
+ dso->filename, cu->cu_offset + type_offset,
+ cu->cu_die->die_offset);
+ goto fail;
+ }
+ if (unlikely (low_mem))
+ {
+ ref->die_referenced = 1;
+ ref->die_intercu_referenced = 1;
+ }
+ }
+ if (unlikely (low_mem))
+ {
+ remove_unneeded (cu, cu->cu_die, 1);
+ remove_unneeded (cu, cu->cu_die, 2);
+ collapse_children (cu, cu->cu_die);
+ }
+ }
+
+ if (unlikely (low_mem_phase1))
+ {
+ low_mem_phase1 = false;
+ cu_chunk = 0;
+ goto low_mem_phase2;
+ }
+
+ if (unlikely (low_mem))
+ ;
+ else if (unlikely (meta_abbrev_htab != NULL))
+ {
+ dw_cu_ref cu;
+
+ if (unlikely (op_multifile))
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ cu->cu_abbrev = NULL;
+ htab_delete (meta_abbrev_htab);
+ meta_abbrev_htab = NULL;
+ obstack_free (&ob2, to_free);
+ abbrev = NULL;
+ }
+ else if (abbrev)
+ htab_delete (abbrev);
+
+ if (unlikely (kind == DEBUG_TYPES))
+ return 0;
+
+ if (unlikely (rd_multifile || fi_multifile))
+ {
+ dw_cu_ref cu;
+
+ /* Inside of read_multifile, DIE hashes are computed
+ only after all the PUs are parsed, as we follow
+ DW_FORM_ref_addr then. */
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ if (checksum_die (dso, cu, NULL, cu->cu_die))
+ goto fail;
+
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ checksum_ref_die (cu, NULL, cu->cu_die, NULL, NULL);
+
+ if (dump_dies_p)
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ dump_dies (0, cu->cu_die);
+
+ if (rd_multifile)
+ {
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ if (find_dups (cu->cu_die))
+ goto fail;
+ }
+ else
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ if (find_dups_fi (cu->cu_die))
+ goto fail;
+
+ return 0;
+ }
+
+ if (tracing)
+ {
+ if (op_multifile)
+ fprintf (stderr, "Die count: %u\n", ndies);
+ else
+ fprintf (stderr, "Die count: %u, %.2f%% of estimate\n", ndies,
+ (double)ndies / ((double)estimated_nr_dies / 100));
+ }
+ if (tracing)
+ htab_report (off_htab, "off_htab post-parsing");
+ if (stats_p)
+ stats->die_count = ndies;
+ if (die_count)
+ *die_count = ndies;
+ htab_delete (dup_htab);
+ dup_htab = NULL;
+ return 0;
+fail:
+ if (unlikely (meta_abbrev_htab != NULL))
+ {
+ dw_cu_ref cu;
+
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ cu->cu_abbrev = NULL;
+ htab_delete (meta_abbrev_htab);
+ meta_abbrev_htab = NULL;
+ obstack_free (&ob2, to_free);
+ }
+ else if (abbrev)
+ htab_delete (abbrev);
+ if (dup_htab && kind == DEBUG_INFO)
+ {
+ htab_delete (dup_htab);
+ dup_htab = NULL;
+ }
+ return ret;
+}
+
+/* Compare function called from qsort, which should ensure that
+ dup candidate dies with the same set of referrer CUs are
+ adjacent. */
+static int
+partition_cmp (const void *p, const void *q)
+{
+ dw_die_ref die1 = *(dw_die_ref *) p;
+ dw_die_ref die2 = *(dw_die_ref *) q;
+ dw_die_ref ref1, ref2;
+ dw_cu_ref last_cu1 = NULL, last_cu2 = NULL;
+ ref1 = die1;
+ ref2 = die2;
+ if (odr_active_p && odr_mode != ODR_BASIC)
+ {
+ while (ref1 && die_odr_state (ref1) == ODR_DECL)
+ ref1 = ref1->die_nextdup;
+ if (ref1 == NULL)
+ ref1 = die1;
+ while (ref2 && die_odr_state (ref2) == ODR_DECL)
+ ref2 = ref2->die_nextdup;
+ if (ref2 == NULL)
+ ref2 = die2;
+ }
+ for (;; ref1 = ref1->die_nextdup, ref2 = ref2->die_nextdup)
+ {
+ dw_cu_ref ref1cu = NULL;
+ dw_cu_ref ref2cu = NULL;
+ while (ref1 && (ref1cu = die_cu (ref1)) == last_cu1)
+ ref1 = ref1->die_nextdup;
+ while (ref2 && (ref2cu = die_cu (ref2)) == last_cu2)
+ ref2 = ref2->die_nextdup;
+ if (ref1 == NULL || ref2 == NULL)
+ break;
+ last_cu1 = ref1cu;
+ last_cu2 = ref2cu;
+ if (last_cu1->cu_offset < last_cu2->cu_offset)
+ return -1;
+ else if (last_cu1->cu_offset > last_cu2->cu_offset)
+ return 1;
+ }
+ if (ref1)
+ return -1;
+ if (ref2)
+ return 1;
+ /* The rest is just to keep sort stable. */
+ if (die1->die_offset < die2->die_offset)
+ return -1;
+ if (die1->die_offset > die2->die_offset)
+ return 1;
+ return 0;
+}
+
+/* Add duplicate chain for DIE to VEC. */
+static void
+partition_found_dups (dw_die_ref die, struct obstack *vec)
+{
+ assert (die->die_ck_state == CK_KNOWN);
+ obstack_ptr_grow (vec, die);
+ if (unlikely (verify_dups_p))
+ verify_dups (die, true);
+
+ if (stats_p)
+ {
+ uint64_t length = 0;
+ for (; die; die = die->die_nextdup)
+ length++;
+ stats->dup_cnt += length;
+ stats->dup_chain_max_length = MAX (stats->dup_chain_max_length, length);
+ stats->dup_chain_cnt++;
+ }
+}
+
+/* Sort duplication chain for HEAD, assuming the chain was formed by
+ die_eq. */
+static void
+sort_dups (dw_die_ref head)
+{
+ dw_die_ref prev = NULL, die, next;
+ /* Sort the die_nextdup list by increasing die_cu ()->cu_chunk.
+ When it is originally added, child has the lowest
+ cu_offset, then the DIEs are sorted in the linked list
+ from highest cu_offset down to lowest or second lowest. */
+ for (die = head->die_nextdup; die; prev = die, die = next)
+ {
+ next = die->die_nextdup;
+ die->die_nextdup = prev;
+ }
+ head->die_nextdup = prev;
+}
+
+/* Merge duplicate chains D and D2, and return the head of the merged
+chain. */
+static dw_die_ref
+merge_dups (dw_die_ref d, dw_die_ref d2)
+{
+ if (d == NULL)
+ return d2;
+ if (d2 == NULL)
+ return d;
+
+ dw_die_ref tail = NULL;
+ dw_die_ref head = NULL;
+ while (true)
+ {
+ dw_die_ref next;
+ if (d && d2)
+ {
+ if (d->die_offset < d2->die_offset)
+ {
+ next = d;
+ d = d->die_nextdup;
+ }
+ else
+ {
+ next = d2;
+ d2 = d2->die_nextdup;
+ }
+ }
+ else if (d)
+ {
+ next = d;
+ d = d->die_nextdup;
+ }
+ else if (d2)
+ {
+ next = d2;
+ d2 = d2->die_nextdup;
+ }
+ else
+ break;
+ if (!head)
+ head = next;
+ if (tail)
+ tail->die_nextdup = next;
+ tail = next;
+ }
+
+ for (d = head; d; d = d->die_nextdup)
+ if (d == head)
+ d->die_dup = NULL;
+ else
+ d->die_dup = head;
+
+ if (unlikely (verify_dups_p))
+ verify_dups (head, true);
+ return head;
+}
+
+static void
+mark_singletons (dw_cu_ref cu, dw_die_ref top_die, dw_die_ref die,
+ struct obstack *vec)
+{
+ struct abbrev_tag *t;
+ unsigned int i;
+ unsigned char *ptr;
+ dw_die_ref child;
+ bool found;
+
+ t = die->die_abbrev;
+
+ found = false;
+ for (i = 0; i < t->nattr; ++i)
+ {
+ struct abbrev_attr *attr = &t->attr[i];
+ if (attr->attr == DW_AT_sibling)
+ continue;
+ switch (attr->form)
+ {
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_indirect:
+ found = true;
+ break;
+ }
+ }
+ if (!found)
+ goto handle_children;
+
+ if (unlikely (cu->cu_kind == CU_TYPES))
+ ptr = debug_sections[DEBUG_TYPES].data;
+ else
+ ptr = debug_sections[DEBUG_INFO].data;
+ ptr += die->die_offset;
+ skip_leb128 (ptr);
+ for (i = 0; i < t->nattr; ++i)
+ {
+ struct abbrev_attr *attr = &t->attr[i];
+ uint32_t form = attr->form;
+ uint64_t value;
+ dw_die_ref ref, reft;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+
+ switch (form)
+ {
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ switch (form)
+ {
+ case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+ case DW_FORM_ref1: value = read_8 (ptr); break;
+ case DW_FORM_ref2: value = read_16 (ptr); break;
+ case DW_FORM_ref4: value = read_32 (ptr); break;
+ case DW_FORM_ref8: value = read_64 (ptr); break;
+ default: abort ();
+ }
+ if (t->attr[i].attr == DW_AT_sibling)
+ break;
+ ref = off_htab_lookup (cu, cu->cu_offset + value);
+ if (!ref->die_collapsed_child
+ && ref->u.p1.die_enter >= top_die->u.p1.die_enter
+ && ref->u.p1.die_exit <= top_die->u.p1.die_exit)
+ break;
+ reft = ref;
+ while (!reft->die_root
+ && reft->die_parent->die_tag != DW_TAG_compile_unit
+ && reft->die_parent->die_tag != DW_TAG_partial_unit
+ && !reft->die_parent->die_named_namespace)
+ reft = reft->die_parent;
+ if (reft->die_dup != NULL || reft->die_nextdup != NULL)
+ break;
+ if (reft->die_ref_seen)
+ break;
+ reft->die_ref_seen = 1;
+ partition_found_dups (reft, vec);
+ mark_singletons (die_cu (reft), reft, reft, vec);
+ break;
+ default:
+ ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+ break;
+ }
+ }
+
+ handle_children:
+ for (child = die->die_child; child; child = child->die_sib)
+ mark_singletons (cu, top_die, child, vec);
+}
+
+/* Split maximal duplicate chain DIE into smaller chains that contain
+ structurally equal defs, and combine the decls with one of those.
+ Return the first chain, and call partition_found_dups for the others. */
+static dw_die_ref
+split_dups (dw_die_ref die, struct obstack *vec)
+{
+ dw_die_ref res = NULL;
+
+ /* Count the DIEs in the duplicate chain. */
+ unsigned count = 0;
+ dw_die_ref d;
+ for (d = die; d; d = d->die_nextdup)
+ count++;
+ assert (count >= 2);
+
+ /* Break up the duplicate chain. */
+ dw_die_ref arr[count];
+ unsigned int i;
+ for (d = die, i = 0; d; d = d->die_nextdup, i++)
+ arr[i] = d;
+ for (i = 0; i < count; i++)
+ {
+ d = arr[i];
+ d->die_nextdup = NULL;
+ d->die_dup = NULL;
+ }
+
+ /* Build decls duplicate chain. */
+ dw_die_ref tail = NULL;
+ dw_die_ref head = NULL;
+ for (i = 0; i < count; i++)
+ {
+ d = arr[i];
+ if (die_odr_state (d) != ODR_DECL)
+ continue;
+ if (!head)
+ head = d;
+ if (tail)
+ tail->die_nextdup = d;
+ if (d != head)
+ d->die_dup = head;
+ tail = d;
+ }
+ dw_die_ref decls = head;
+
+ /* Build def duplicate chains. */
+ unsigned int j;
+ dw_die_ref d2;
+ for (i = 0; i < count; i++)
+ {
+ d = arr[i];
+ if (d->die_dup || d->die_nextdup
+ || die_odr_state (d) == ODR_DECL)
+ continue;
+ tail = d;
+ for (j = i + 1; j < count; j++)
+ {
+ d2 = arr[j];
+ if (d2->die_dup || d2->die_nextdup
+ || die_odr_state (d2) == ODR_DECL)
+ continue;
+ die_eq (d, d2);
+ }
+ sort_dups (d);
+ }
+
+ if (odr_mode != ODR_BASIC)
+ {
+ /* Find the first duplicate chain containing defs. */
+ dw_die_ref def = NULL;
+ for (i = 0; i < count; i++)
+ {
+ d = arr[i];
+ if (die_odr_state (d) == ODR_DECL
+ || d->die_dup != NULL)
+ continue;
+ def = d;
+ break;
+ }
+
+ /* Merge the def chain with the decls. */
+ merge_dups (def, decls);
+ }
+
+ for (i = 0; i < count; i++)
+ {
+ d = arr[i];
+ if (d->die_dup == NULL)
+ /* If DIE is now either:
+ - no longer part of a duplicate chain, or
+ - head of a duplicate chain,
+ don't remove it. */
+ d->die_remove = 0;
+ }
+
+ /* Notice the new duplicate chains. */
+ for (i = 0; i < count; i++)
+ {
+ d = arr[i];
+ if (d->die_dup != NULL)
+ continue;
+ if (res == NULL)
+ res = d;
+ else
+ partition_found_dups (d, vec);
+ }
+ return res;
+}
+
+/* Search for duplicate removal reference DIE candidates
+ in tree rooted by PARENT. */
+static void
+partition_find_dups (struct obstack *vec, dw_die_ref parent)
+{
+ dw_die_ref child;
+ for (child = parent->die_child; child; child = child->die_sib)
+ {
+ if (child->die_nextdup != NULL
+ && child->die_dup == NULL
+ && child->die_offset != -1U)
+ {
+ dw_die_ref die;
+
+ if (unlikely (op_multifile))
+ {
+ /* If all the dups are from the same DSO or executable,
+ there is nothing in it to optimize in between different
+ objects. */
+ unsigned int cu_chunk = die_cu (child)->cu_chunk;
+ for (die = child->die_nextdup; die; die = die->die_nextdup)
+ if (die_cu (die)->cu_chunk != cu_chunk)
+ break;
+ if (die == NULL)
+ continue;
+ }
+ sort_dups (child);
+ partition_found_dups (child, vec);
+ }
+ else if (child->die_named_namespace)
+ partition_find_dups (vec, child);
+ }
+}
+
+/* Reorder duplicate chain DIE to make sure it doesn't start with a decl. */
+static dw_die_ref
+reorder_dups (dw_die_ref die)
+{
+ unsigned decl_count = 0;
+ unsigned def_count = 0;
+ dw_die_ref d;
+
+ if (die_odr_state (die) == ODR_NONE)
+ return die;
+
+ for (d = die; d; d = d->die_nextdup)
+ {
+ if (die_odr_state (d) == ODR_DECL)
+ decl_count++;
+ else
+ def_count++;
+ }
+ if (def_count == 0 || decl_count == 0)
+ return die;
+
+ if (die_odr_state (die) != ODR_DECL)
+ return die;
+
+ dw_die_ref def = NULL;
+ dw_die_ref prev = NULL;
+ for (d = die; d; prev = d, d = d->die_nextdup)
+ {
+ if (die_odr_state (d) == ODR_DECL)
+ continue;
+ def = d;
+ break;
+ }
+
+ assert (!die->die_remove);
+ assert (def->die_remove);
+ def->die_remove = 0;
+ die->die_remove = 1;
+ def->die_ref_seen = die->die_ref_seen;
+ dw_die_ref next = def->die_nextdup;
+ if (prev)
+ prev->die_nextdup = next;
+ def->die_nextdup = die;
+ for (d = def; d; prev = d, d = d->die_nextdup)
+ {
+ if (d == def)
+ d->die_dup = NULL;
+ else
+ d->die_dup = def;
+ }
+
+ if (unlikely (verify_dups_p))
+ verify_dups (def, false);
+ return def;
+}
+
+/* Copy DIE tree of DIE, as children of new DIE PARENT. */
+static dw_die_ref
+copy_die_tree (dw_die_ref parent, dw_die_ref die)
+{
+ dw_die_ref child, new_child, *diep;
+ dw_die_ref new_die;
+ if (die->die_toplevel)
+ {
+ new_die = pool_alloc (dw_die, sizeof (struct dw_die));
+ memset (new_die, '\0', sizeof (*new_die));
+ new_die->die_toplevel = 1;
+ die->die_dup = new_die;
+ new_die->die_nextdup = die;
+ if (!die->die_op_type_referenced)
+ die->die_remove = 1;
+ }
+ else
+ {
+ new_die = pool_alloc (dw_die, offsetof (struct dw_die, die_dup));
+ memset (new_die, '\0', offsetof (struct dw_die, die_dup));
+ }
+ new_die->die_parent = parent;
+ new_die->die_tag = die->die_tag;
+ new_die->die_offset = -1U;
+ new_die->die_size = die->die_size;
+ diep = &new_die->die_child;
+ for (child = die->die_child; child; child = child->die_sib)
+ {
+ new_child = copy_die_tree (new_die, child);
+ *diep = new_child;
+ diep = &new_child->die_sib;
+ }
+ return new_die;
+}
+
+/* If all DIEs in the duplication chain DIE are in CUs with the same
+ language, return that language. Otherwise, return 0. */
+static enum dwarf_source_language
+partition_lang (dw_die_ref die)
+{
+ enum dwarf_source_language lang;
+ dw_die_ref d;
+
+ if (die == NULL)
+ return 0;
+
+ lang = die_cu (die)->lang;
+ switch (lang)
+ {
+ case DW_LANG_C_plus_plus:
+ case DW_LANG_C_plus_plus_03:
+ case DW_LANG_C_plus_plus_11:
+ case DW_LANG_C_plus_plus_14:
+ break;
+ default:
+ return 0;
+ }
+
+ for (d = die->die_nextdup; d; d = d->die_nextdup)
+ if (die_cu (d)->lang != lang)
+ return 0;
+
+ return lang;
+}
+
+/* Return how many bytes we need to encode VAL. */
+static unsigned int
+nr_bytes_for (uint64_t val)
+{
+ unsigned int n;
+
+ if (val == 0)
+ return 1;
+
+ for (n = 0; val > 0; n++)
+ val = val >> 8;
+
+ return n;
+}
+
+/* Return true if duplicate chains REF1 and REF2 have the same set of
+ referrer CUs. If so, return the number of unique referrer CUs
+ in *CNT. */
+static inline unsigned int FORCE_INLINE
+same_ref_cus_p (dw_die_ref ref1, dw_die_ref ref2, size_t *cnt)
+{
+ dw_cu_ref last_cu1 = NULL, last_cu2 = NULL;
+
+ *cnt = 0;
+
+ if (odr_active_p && odr_mode != ODR_BASIC)
+ {
+ dw_die_ref orig_ref1 = ref1, orig_ref2 = ref2;
+ while (ref1 && die_odr_state (ref1) == ODR_DECL)
+ ref1 = ref1->die_nextdup;
+ if (ref1 == NULL)
+ ref1 = orig_ref1;
+ while (ref2 && die_odr_state (ref2) == ODR_DECL)
+ ref2 = ref2->die_nextdup;
+ if (ref2 == NULL)
+ ref2 = orig_ref2;
+ }
+ for (;; ref1 = ref1->die_nextdup, ref2 = ref2->die_nextdup)
+ {
+ dw_cu_ref ref1cu = NULL;
+ dw_cu_ref ref2cu = NULL;
+
+ while (ref1 && (ref1cu = die_cu (ref1)) == last_cu1)
+ ref1 = ref1->die_nextdup;
+ while (ref2 && (ref2cu = die_cu (ref2)) == last_cu2)
+ ref2 = ref2->die_nextdup;
+ if (ref1 == NULL || ref2 == NULL)
+ break;
+
+ last_cu1 = ref1cu;
+ last_cu2 = ref2cu;
+
+ if (last_cu1 != last_cu2)
+ break;
+ else
+ (*cnt)++;
+ }
+
+ if (ref1 || ref2)
+ return false;
+
+ return true;
+}
+
+/* Return the number of unique referrer CUs in duplicate chain REF. */
+static inline size_t FORCE_INLINE
+cnt_ref_cus (dw_die_ref ref)
+{
+ dw_cu_ref last_cu1 = NULL;
+ size_t cnt = 0;
+
+ for (;; ref = ref->die_nextdup)
+ {
+ dw_cu_ref refcu = NULL;
+ while (ref && (refcu = die_cu (ref)) == last_cu1)
+ ref = ref->die_nextdup;
+ if (ref == NULL)
+ break;
+ last_cu1 = refcu;
+ cnt++;
+ }
+
+ return cnt;
+}
+
+/* Helper function of partition_dups_1. Decide what DIEs matching in
+ multiple CUs might be worthwhile to be moved into partial units,
+ construct those partial units. */
+static bool
+partition_dups_1 (dw_die_ref *arr, size_t nr_partitions, size_t *partitions,
+ dw_cu_ref *first_partial_cu,
+ dw_cu_ref *last_partial_cu,
+ bool second_phase)
+{
+ size_t i, j, cnt;
+ bool ret = false;
+ size_t idx = 0;
+ for (idx = 0; idx < nr_partitions * 2; idx += 2)
+ {
+ i = partitions[idx];
+ cnt = partitions[idx + 1];
+ j = partitions[idx + 2];
+
+ if (arr[i]->die_dup != NULL)
+ continue;
+
+ dw_die_ref ref;
+ size_t size = 0, k, orig_size, new_size, namespaces = 0;
+ unsigned int force = 0;
+ enum dwarf_source_language part_lang
+ = gen_cu_p ? partition_lang (arr[i]) : 0;
+ for (k = i; k < j; k++)
+ {
+ if (second_phase && arr[k]->die_ref_seen)
+ force++;
+ size += calc_sizes (arr[k]);
+ for (ref = arr[k]->die_parent;
+ ref->die_named_namespace && ref->die_dup == NULL;
+ ref = ref->die_parent)
+ {
+ ref->die_dup = arr[k];
+ namespaces++;
+ }
+ }
+ /* If during second_phase there are some DIEs we want to force
+ into a partial unit because they are referenced from something
+ already forced into a partial unit, but also some DIEs with
+ the same set of referrers, try to see if we can put also those
+ into the partial unit. They can be put there only if they
+ don't refer to DIEs that won't be put into partial units. */
+ if (unlikely (partition_dups_opt)
+ && second_phase && force && force < j - i)
+ {
+ /* First optimistically assume all such DIEs can be put there,
+ thus mark all such DIEs as going to be included, so that
+ even if one of those DIEs references another one from those
+ DIEs it can be included. */
+ for (k = i; k < j; k++)
+ {
+ assert (arr[k]->die_ref_seen < 2);
+ if (arr[k]->die_ref_seen == 0)
+ arr[k]->die_ref_seen = 2;
+ }
+ for (k = i; k < j; k++)
+ if (arr[k]->die_ref_seen == 2
+ && !mark_refs (die_cu (arr[k]), arr[k], arr[k],
+ (MARK_REFS_FOLLOW_DUPS | MARK_REFS_RETURN_VAL)))
+ break;
+ /* If that is not possible and some DIEs couldn't be included,
+ fallback to assume other DIEs won't be included. */
+ if (k < j)
+ {
+ for (k = i; k < j; k++)
+ if (arr[k]->die_ref_seen == 2)
+ arr[k]->die_ref_seen = 0;
+ for (k = i; k < j; k++)
+ if (arr[k]->die_ref_seen == 0)
+ {
+ arr[k]->die_ref_seen = 2;
+ if (!mark_refs (die_cu (arr[k]), arr[k], arr[k],
+ (MARK_REFS_FOLLOW_DUPS
+ | MARK_REFS_RETURN_VAL)))
+ arr[k]->die_ref_seen = 0;
+ }
+ }
+ }
+ if (namespaces)
+ {
+ for (k = i; k < j; k++)
+ for (ref = arr[k]->die_parent; ref->die_named_namespace;
+ ref = ref->die_parent)
+ ref->die_dup = NULL;
+ }
+ orig_size = size * cnt;
+ /* Estimated size of CU header and DW_TAG_partial_unit
+ with DW_AT_stmt_list and DW_AT_comp_dir attributes
+ 21 (also child end byte). With DW_AT_language c++, 22. */
+ size_t pu_size
+ = (/* CU Header: unit length (initial length).
+ 32-bit DWARF: 4 bytes, 64-bit DWARF: 12 bytes. */
+ 4
+ /* CU Header: version (uhalf).
+ 2 bytes. */
+ + 2
+ /* CU Header: debug_abbrev_offset (section offset).
+ 32-bit DWARF: 4 bytes, 64-bit DWARF: 8 bytes. */
+ + 4
+ /* CU Header: address_size (ubyte).
+ 1 byte. */
+ + 1
+ /* DWARF5 CU header: unit_type (ubyte). */
+ + (die_cu (arr[i])->cu_version >= 5 ? 1 : 0)
+ /* CU Root DIE: abbreviation code (unsigned LEB128).
+ 1 or more bytes. Optimistically assume 1. */
+ + 1
+ /* CU Root DIE: DW_AT_stmt_list (lineptr).
+ 32-bit DWARF: 4 bytes, 64-bit DWARF: 8 bytes. */
+ + 4
+ /* CU Root DIE: DW_AT_comp_dir (string).
+ DW_FORM_strp: 32-bit DWARF: 4 bytes, 64-bit DWARF: 8 bytes.
+ DW_FORM_string: 1 or more bytes.
+ Assume 4 bytes. */
+ + 4
+ /* CU Root DIE: DW_AT_language (constant).
+ 1 or 2 bytes. */
+ + ((uni_lang_p || part_lang)
+ ? nr_bytes_for (die_cu (arr[i])->lang)
+ : 0)
+ /* CU root DIE children terminator: abbreviation code 0
+ (unsigned LEB128).
+ 1 byte. */
+ + 1);
+ /* DW_TAG_imported_unit with DW_AT_import attribute
+ (5 or 9 bytes (the latter for DWARF2 and ptr_size 8)). */
+ size_t import_size
+ = (die_cu (arr[i])->cu_version == 2 ? 1 + ptr_size : 5);
+ /* For DW_TAG_namespace or DW_TAG_module needed as
+ parents of the DIEs conservatively assume 10 bytes
+ for the abbrev index, DW_AT_name attribute and
+ DW_AT_sibling attribute and child end. */
+ size_t namespace_size = 10;
+ new_size = (/* Size of DIEs. */
+ size
+ /* Size of PU. */
+ + pu_size
+ /* Size of imports. */
+ + (part_lang != 0 ? 0 : import_size * cnt)
+ /* Size of namespace DIEs. */
+ + namespace_size * namespaces);
+ if (!second_phase)
+ force = ((deduplication_mode == dm_inter_cu)
+ && (ignore_size || orig_size > new_size));
+ if (force)
+ {
+ dw_die_ref die, *diep;
+ dw_cu_ref refcu = die_cu (arr[i]);
+ dw_cu_ref partial_cu = pool_alloc (dw_cu, sizeof (struct dw_cu));
+ memset (partial_cu, '\0', sizeof (*partial_cu));
+ if (stats_p)
+ {
+ if (!second_phase)
+ stats->pu_ph1_cnt++;
+ else
+ stats->pu_ph2_cnt++;
+ }
+ partial_cu->cu_kind = CU_PU;
+ partial_cu->cu_offset = *last_partial_cu == NULL
+ ? 0 : (*last_partial_cu)->cu_offset + 1;
+ if (dump_pus_p)
+ fprintf (stderr, "Partial unit (%s) @ 0x%x:\n",
+ second_phase ? "phase two" : "phase one",
+ partial_cu->cu_offset);
+ partial_cu->cu_version = refcu->cu_version;
+ if (uni_lang_p)
+ partial_cu->lang = refcu->lang;
+ if (*first_partial_cu == NULL)
+ *first_partial_cu = *last_partial_cu = partial_cu;
+ else
+ {
+ (*last_partial_cu)->cu_next = partial_cu;
+ *last_partial_cu = partial_cu;
+ }
+ die = pool_alloc (dw_die, sizeof (struct dw_die));
+ memset (die, '\0', sizeof (*die));
+ die->die_toplevel = 1;
+ partial_cu->cu_die = die;
+ die->die_tag = DW_TAG_partial_unit;
+ die->die_offset = -1U;
+ die->die_root = 1;
+ die->die_parent = (dw_die_ref) partial_cu;
+ die->die_nextdup = refcu->cu_die;
+ die->die_size = 9;
+ diep = &die->die_child;
+ for (k = i; k < j; k++)
+ {
+ dw_die_ref child;
+ if (second_phase && !arr[k]->die_ref_seen)
+ continue;
+ if (dump_pus_p)
+ dump_die (arr[k]);
+ child = copy_die_tree (die, arr[k]);
+ if (stats_p)
+ stats->pu_toplevel_die_cnt++;
+ for (ref = arr[k]->die_nextdup; ref; ref = ref->die_nextdup)
+ ref->die_dup = child;
+ if (unlikely (verify_dups_p))
+ verify_dups (child, odr_mode == ODR_BASIC);
+ if (part_lang != 0)
+ {
+ die->die_tag = DW_TAG_compile_unit;
+ partial_cu->lang = part_lang;
+ }
+ if (namespaces)
+ {
+ for (ref = arr[k]->die_parent;
+ ref->die_named_namespace && ref->die_dup == NULL;
+ ref = ref->die_parent)
+ {
+ dw_die_ref namespc
+ = pool_alloc (dw_die, sizeof (struct dw_die));
+ memset (namespc, '\0', sizeof (struct dw_die));
+ namespc->die_toplevel = 1;
+ namespc->die_tag = ref->die_tag;
+ namespc->die_offset = -1U;
+ namespc->die_nextdup = ref;
+ namespc->die_child = child;
+ namespc->die_parent = die;
+ namespc->die_size = 9;
+ namespc->die_named_namespace = 1;
+ child->die_parent = namespc;
+ ref->die_dup = namespc;
+ child = namespc;
+ }
+ if (ref->die_dup != NULL)
+ {
+ dw_die_ref *diep2;
+ for (diep2 = &ref->die_dup->die_child->die_sib;
+ *diep2; diep2 = &(*diep2)->die_sib)
+ ;
+ *diep2 = child;
+ child->die_parent = ref->die_dup;
+ continue;
+ }
+ }
+ *diep = child;
+ diep = &child->die_sib;
+ }
+ if (namespaces)
+ {
+ for (k = i; k < j; k++)
+ {
+ if (second_phase && !arr[k]->die_ref_seen)
+ continue;
+ for (ref = arr[k]->die_parent;
+ ref->die_named_namespace; ref = ref->die_parent)
+ ref->die_dup = NULL;
+ }
+ }
+ }
+ else if (!second_phase)
+ ret = true;
+ if (second_phase)
+ {
+ dw_die_ref next;
+ for (k = i; k < j; k++)
+ {
+ if (arr[k]->die_dup != NULL)
+ continue;
+ for (ref = arr[k]; ref; ref = next)
+ {
+ dw_cu_ref refcu = die_cu (ref);
+ next = ref->die_nextdup;
+ ref->die_dup = NULL;
+ ref->die_nextdup = NULL;
+ ref->die_remove = 0;
+ /* If there are dups within a single CU
+ (arguably a bug in the DWARF producer),
+ keep them linked together, but don't link
+ DIEs across different CUs. */
+ while (deduplication_mode != dm_none
+ && next && refcu == die_cu (next))
+ {
+ dw_die_ref cur = next;
+ next = cur->die_nextdup;
+ cur->die_dup = ref;
+ cur->die_nextdup = ref->die_nextdup;
+ ref->die_nextdup = cur;
+ }
+ }
+ }
+ }
+ }
+ return ret;
+}
+
+/* Partition the duplicate chains in array ARR with size VEC_SIZE, and store
+ the partitions on obstack ob2, with for each partition two entries:
+ the start and the number of unique reffer CUs. */
+static void
+calculate_partitions (dw_die_ref *arr, size_t vec_size)
+{
+ size_t i, j;
+ for (i = 0; i < vec_size; i = j)
+ {
+ size_t cnt = 0;
+ for (j = i + 1; j < vec_size; j++)
+ {
+ size_t this_cnt;
+ if (!same_ref_cus_p (arr[i], arr[j], &this_cnt))
+ break;
+ cnt = this_cnt;
+ }
+ if (cnt == 0)
+ cnt = cnt_ref_cus (arr[i]);
+ obstack_grow (&ob2, &i, sizeof (size_t));
+ obstack_grow (&ob2, &cnt, sizeof (size_t));
+ }
+
+ /* Add element to mark end of partition list. This allows us to do
+ 'j = partitions[idx + 2]' for all partitions. */
+ obstack_grow (&ob2, &j, sizeof (size_t));
+ size_t zero = 0;
+ obstack_grow (&ob2, &zero, sizeof (size_t));
+}
+
+static inline void FORCE_INLINE
+reset_die_ref_seen (void)
+{
+ dw_die_ref die;
+ dw_cu_ref cu;
+ FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+ die->die_ref_seen = 0;
+}
+
+/* If the duplicate chain DIE consists of a singleton ODR_DEF die merged with
+ the ODR_DECL chain, return the singleton ODR_DEF die. Otherwise, return
+ NULL. */
+static inline dw_die_ref FORCE_INLINE
+merged_singleton (dw_die_ref die)
+{
+ dw_die_ref res = NULL;
+ dw_die_ref d;
+ size_t decl_cnt = 0;
+
+ for (d = die; d; d = d->die_nextdup)
+ switch (die_odr_state (d))
+ {
+ case ODR_DEF:
+ if (res)
+ {
+ if (die_cu (res) == die_cu (d))
+ continue;
+ else
+ return NULL;
+ }
+ else
+ res = d;
+ break;
+ case ODR_DECL:
+ decl_cnt++;
+ break;
+ default:
+ return NULL;
+ }
+
+ if (decl_cnt == 0)
+ return NULL;
+
+ return res;
+}
+
+/* Decide what DIEs matching in multiple CUs might be worthwhile
+ to be moved into partial units, construct those partial units. */
+static int
+partition_dups (void)
+{
+ dw_cu_ref cu, first_partial_cu = NULL, last_partial_cu = NULL;
+ size_t vec_size, i;
+ unsigned char *to_free;
+ dw_die_ref *arr;
+
+ if (unlikely (fi_multifile))
+ return 0;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "partition_dups\n");
+ }
+
+ to_free = obstack_alloc (&ob2, 1);
+
+ if (odr_active_p)
+ odr_phase = 2;
+
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ partition_find_dups (&ob2, cu->cu_die);
+ vec_size = obstack_object_size (&ob2) / sizeof (void *);
+
+ if (odr_active_p)
+ {
+ arr = (dw_die_ref *) obstack_base (&ob2);
+ if (progress_p)
+ {
+ report_progress ();
+ fprintf (stderr, "partition_dups split_dups\n");
+ }
+ for (i = 0; i < vec_size; i++)
+ {
+ dw_die_ref die = arr[i];
+ if (die_odr_state (die) == ODR_NONE)
+ continue;
+ die = split_dups (die, &ob2);
+ assert (die != NULL);
+ if (unlikely (verify_dups_p))
+ verify_dups (die, true);
+ arr = (dw_die_ref *) obstack_base (&ob2);
+ arr[i] = die;
+ }
+
+ vec_size = obstack_object_size (&ob2) / sizeof (void *);
+
+ reset_die_ref_seen ();
+ for (i = 0; i < vec_size; i++)
+ {
+ dw_die_ref die = arr[i];
+ if (die->die_dup == NULL
+ && die->die_nextdup == NULL)
+ die->die_ref_seen = 1;
+ }
+ for (i = 0; i < vec_size; i++)
+ {
+ dw_die_ref die = arr[i];
+ if (die->die_dup == NULL
+ && die->die_nextdup == NULL)
+ mark_singletons (die_cu (die), die, die, &ob2);
+ else if (odr_mode != ODR_BASIC
+ && die_odr_state (die) != ODR_NONE)
+ {
+ dw_die_ref s = merged_singleton (die);
+ if (s)
+ mark_singletons (die_cu (s), s, s, &ob2);
+ }
+ else if (cnt_ref_cus (die) == 1)
+ mark_singletons (die_cu (die), die, die, &ob2);
+
+ arr = (dw_die_ref *) obstack_base (&ob2);
+ }
+
+ vec_size = obstack_object_size (&ob2) / sizeof (void *);
+ }
+
+ if (odr_active_p)
+ odr_phase = 3;
+
+ if (stats_p)
+ print_dups_stats ();
+
+ if (vec_size != 0)
+ {
+ arr = (dw_die_ref *) obstack_finish (&ob2);
+ if (odr_active_p)
+ for (i = 0; i < vec_size; ++i)
+ {
+ assert (arr[i] != NULL);
+ if (unlikely (verify_dups_p))
+ verify_dups (arr[i], true);
+ }
+ if (dump_dups_p)
+ {
+ for (i = 0; i < vec_size; ++i)
+ {
+ fprintf (stderr, "duplicate chain:\n");
+ dump_dups (arr[i]);
+ }
+ }
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "partition_dups qsort\n");
+ }
+ qsort (arr, vec_size, sizeof (dw_die_ref), partition_cmp);
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "partition_dups after qsort\n");
+ }
+
+ size_t *partitions = (size_t *) obstack_base (&ob2);
+ calculate_partitions (arr, vec_size);
+ size_t nr_partitions
+ = (obstack_object_size (&ob2) / sizeof (size_t)) / 2 - 1;
+ partitions = (size_t *) obstack_finish (&ob2);
+ if (stats_p)
+ stats->part_cnt += nr_partitions;
+
+ if (odr_active_p && odr_mode != ODR_BASIC)
+ for (i = 0; i < vec_size; ++i)
+ arr[i] = reorder_dups (arr[i]);
+ if (partition_dups_1 (arr, nr_partitions, partitions, &first_partial_cu,
+ &last_partial_cu, false))
+ {
+ for (i = 0; i < vec_size; i++)
+ arr[i]->die_ref_seen = arr[i]->die_dup != NULL;
+ for (i = 0; i < vec_size; i++)
+ if (arr[i]->die_dup != NULL)
+ mark_refs (die_cu (arr[i]), arr[i], arr[i],
+ MARK_REFS_FOLLOW_DUPS);
+ partition_dups_1 (arr, nr_partitions, partitions, &first_partial_cu,
+ &last_partial_cu, true);
+ for (i = 0; i < vec_size; i++)
+ arr[i]->die_ref_seen = 0;
+ }
+ }
+ if (first_partial_cu)
+ {
+ last_partial_cu->cu_next = first_cu;
+ first_cu = first_partial_cu;
+ }
+ obstack_free (&ob2, to_free);
+
+ if (stats_p)
+ print_part_stats ();
+
+ return 0;
+}
+
+/* The create_import_tree function below and all its helper
+ data structures and functions attempt to optimize the size of
+ DW_TAG_imported_unit DIEs, from the initial assumption that
+ each CU that needs to include some newly created DW_TAG_partial_unit
+ will contain DW_TAG_imported_unit for each such partial unit (PU)
+ (so basically a bipartite graph with CUs and PUs as nodes
+ and DW_TAG_imported_unit DIEs as edges) into a tree, where some
+ of the partial units may also include DW_TAG_imported_unit
+ DIEs, or when beneficial new PUs are created to hold some
+ DW_TAG_imported_unit DIEs. */
+
+struct import_edge;
+
+/* Structure describing details about a CU or PU (i.e. a node
+ in the graph). */
+struct import_cu
+{
+ /* Corresponding CU. CU->u1.cu_icu points back to this
+ structure while in create_import_tree. */
+ dw_cu_ref cu;
+ /* Linked list of incoming resp. outgoing edges. */
+ struct import_edge *incoming, *outgoing;
+ /* The tail of the linked list of incoming edges. */
+ struct import_edge *incoming_tail;
+ /* Next import_cu (used to chain PUs together). */
+ struct import_cu *next;
+ /* Number of incoming resp. outgoing edges. */
+ unsigned int incoming_count, outgoing_count;
+ /* Index. Lowest indexes are assigned to partition_dups
+ created PUs (sorted by decreasing number of incoming
+ edges at the start), then referencing CUs
+ (similarly, sorted by decreasing number of outgoing
+ edges at the start), then optionally any PUs
+ created by create_import_tree. */
+ unsigned int idx;
+};
+
+/* An edge in a linked list. */
+struct import_edge
+{
+ struct import_cu *icu;
+ struct import_edge *next;
+};
+
+/* Called through qsort to sort an array of edges by decreasing
+ incoming resp. outgoing_count (this is called when the graph
+ is bipartite, so CUs only have non-zero outgoing_count
+ and PUs only have non-zero incoming_count). */
+static int
+import_edge_cmp (const void *p, const void *q)
+{
+ struct import_edge *e1 = (struct import_edge *) p;
+ struct import_edge *e2 = (struct import_edge *) q;
+ if (e1->icu->incoming_count > e2->icu->incoming_count)
+ return -1;
+ if (e1->icu->incoming_count < e2->icu->incoming_count)
+ return 1;
+ if (e1->icu->outgoing_count > e2->icu->outgoing_count)
+ return -1;
+ if (e1->icu->outgoing_count < e2->icu->outgoing_count)
+ return 1;
+ /* The rest is just to keep qsort stable. */
+ if (e1->icu->cu->cu_offset < e2->icu->cu->cu_offset)
+ return -1;
+ if (e1->icu->cu->cu_offset > e2->icu->cu->cu_offset)
+ return 1;
+ return 0;
+}
+
+/* Called through qsort to sort an array of CUs/PUs by decreasing
+ incoming resp. outgoing_count (this is called when the graph
+ is bipartite, so CUs only have non-zero outgoing_count
+ and PUs only have non-zero incoming_count). */
+static int
+import_cu_cmp (const void *p, const void *q)
+{
+ struct import_cu *c1 = *(struct import_cu **) p;
+ struct import_cu *c2 = *(struct import_cu **) q;
+ if (c1->incoming_count > c2->incoming_count)
+ return -1;
+ if (c1->incoming_count < c2->incoming_count)
+ return 1;
+ if (c1->outgoing_count > c2->outgoing_count)
+ return -1;
+ if (c1->outgoing_count < c2->outgoing_count)
+ return 1;
+ /* The rest is just to keep qsort stable. */
+ if (c1->cu->cu_offset < c2->cu->cu_offset)
+ return -1;
+ if (c1->cu->cu_offset > c2->cu->cu_offset)
+ return 1;
+ return 0;
+}
+
+/* Freelist for removed edges. */
+static struct import_edge *edge_freelist;
+
+/* Prepare edge E to add to edge_freelist. */
+static inline void FORCE_INLINE
+prepare_free_edge (struct import_edge *e UNUSED)
+{
+#if DEVEL
+ e->icu = (void *)(uintptr_t)-1;
+#endif
+}
+
+/* Add edge E to edge_freelist. */
+static inline void FORCE_INLINE
+free_edge (struct import_edge *e)
+{
+ prepare_free_edge (e);
+ e->next = edge_freelist;
+ edge_freelist = e;
+}
+
+/* Add edge list starting at HEAD and ending at TAIL to edge_freelist.
+ Assume that prepare_free_edge has been called on all elements. */
+static inline void FORCE_INLINE
+free_edges (struct import_edge *head, struct import_edge *tail)
+{
+#if DEVEL
+ if (verify_edge_freelist)
+ {
+ struct import_edge *e;
+ for (e = head; e; e = e->next)
+ {
+ assert (e->icu == (void *)(uintptr_t)-1);
+ if (e == tail)
+ break;
+ }
+ assert (e != NULL);
+ }
+#endif
+ tail->next = edge_freelist;
+ edge_freelist = head;
+}
+
+/* Detach an edge from edge_freelist, and return it. */
+static inline struct import_edge * FORCE_INLINE
+edge_from_freelist (void)
+{
+#if DEVEL
+ assert (edge_freelist);
+#endif
+ struct import_edge *e = edge_freelist;
+ edge_freelist = edge_freelist->next;
+#if DEVEL
+ e->next = (void *)(uintptr_t)-1;
+#endif
+ return e;
+}
+
+/* Return edge_freelist, and set it to NULL. */
+static inline struct import_edge * FORCE_INLINE
+first_edge_from_freelist (void)
+{
+#if DEVEL
+ assert (edge_freelist);
+#endif
+ struct import_edge *e = edge_freelist;
+#if DEVEL
+ edge_freelist = NULL;
+#endif
+ return e;
+}
+
+/* Set edge_freelist to TAIL->next and return HEAD. Assume HEAD was returned
+ by first_edge_from_freelist, and TAIL is reachable from HEAD. */
+static inline struct import_edge * FORCE_INLINE
+last_edge_from_freelist (struct import_edge *head, struct import_edge *tail)
+{
+#if DEVEL
+ assert (!edge_freelist);
+ if (verify_edge_freelist)
+ {
+ struct import_edge *e;
+ for (e = head; e; e = e->next)
+ {
+ if (e == tail)
+ break;
+ }
+ assert (e != NULL);
+ }
+#endif
+ edge_freelist = tail->next;
+ tail->next = NULL;
+ return head;
+}
+
+/* Remove edges in linked list EP that refer to CUS, which
+ is an array of CUCOUNT CUs/PUs. If ADD is true, additionally
+ add a new edge at the end of the linked list and return it. */
+static struct import_edge *
+remove_import_edges (struct import_edge **ep, struct import_edge **ep_tail,
+ struct import_cu **cus, unsigned int cucount, bool add)
+{
+ unsigned int i = 0;
+ struct import_edge *e, *efirst = NULL, *prev = NULL;
+ while (*ep)
+ if (i < cucount && (*ep)->icu == cus[i])
+ {
+ e = *ep;
+ *ep = e->next;
+ if (efirst == NULL)
+ efirst = e;
+ else
+ free_edge (e);
+ i++;
+ if (ep_tail && *ep_tail == e)
+ *ep_tail = prev;
+ if (i == cucount && !add)
+ return NULL;
+ }
+ else
+ {
+ if (ep_tail)
+ prev = *ep;
+ ep = &(*ep)->next;
+ }
+ assert (i == cucount);
+ *ep = efirst;
+ efirst->next = NULL;
+ if (ep_tail)
+ *ep_tail = efirst;
+ return efirst;
+}
+
+static void
+dump_edges_1 (struct import_cu *ipu)
+{
+ fprintf (stderr, "idx: %u\n", ipu->idx);
+ fprintf (stderr, "cu: 0x%x\n", ipu->cu->cu_offset);
+ struct import_edge *e1;
+ for (e1 = ipu->incoming; e1; e1 = e1->next)
+ fprintf (stderr, "incoming: %u\n", e1->icu->idx);
+ for (e1 = ipu->outgoing; e1; e1 = e1->next)
+ fprintf (stderr, "outgoing: %u\n", e1->icu->idx);
+}
+
+static void
+dump_edges (const char *msg, struct import_cu **ipus, unsigned int npus,
+ unsigned int ncus)
+{
+ struct import_cu *ipu;
+ unsigned int i;
+ fprintf (stderr, "PRINT_EDGES: %s\n", msg);
+ fprintf (stderr, "PUs\n");
+ for (ipu = ipus[0]; ipu; ipu = ipu->next)
+ dump_edges_1 (ipu);
+ fprintf (stderr, "CUs\n");
+ for (i = 0; i < ncus; i++)
+ dump_edges_1 (ipus[i + npus]);
+}
+
+/* Enumerate the different kinds of nodes in the import_cu/import_edge
+ graph. */
+enum node_kind { NODE_CU, NODE_PU_INITIAL, NODE_PU_NEW };
+
+/* Return the node kind for node IDX, given that:
+ - [0, NPUS - 1] are initial PUs,
+ - [NPUS, NPUS + NCUS - 1] are CUs, and
+ - [NPUS + NCUS, ] are new PUs. */
+static enum node_kind
+get_node_kind (unsigned int idx, unsigned int npus, unsigned int ncus)
+{
+ if (idx < npus)
+ return NODE_PU_INITIAL;
+ if (idx < npus + ncus)
+ return NODE_CU;
+ return NODE_PU_NEW;
+}
+
+/* Verify an edge from SRC to DEST during create_import_tree phase PHASE. */
+static void
+verify_edge (enum node_kind src, enum node_kind dest, unsigned int phase)
+{
+ if (phase == 1)
+ {
+ assert (src == NODE_CU && dest == NODE_PU_INITIAL);
+ return;
+ }
+
+ assert (IMPLIES (src == NODE_CU, dest != NODE_CU));
+
+ if (phase == 2)
+ {
+ assert (IMPLIES (src == NODE_PU_NEW, dest == NODE_PU_INITIAL));
+ assert (src != NODE_PU_INITIAL);
+ }
+ else
+ assert (IMPLIES (src == NODE_PU_NEW, dest != NODE_CU));
+}
+
+/* Helper function for debugging create_import_tree. Verify
+ various invariants for CU/PU IPU. */
+static void
+verify_edges_1 (struct import_cu *ipu, unsigned int *ic, unsigned int *oc,
+ enum node_kind kind, unsigned int npus, unsigned int ncus,
+ unsigned int phase)
+{
+ struct import_edge *e1, *e2;
+ unsigned int last_idx, count;
+ enum node_kind kind2;
+
+ for (last_idx = 0, count = 0, e1 = ipu->incoming;
+ e1;
+ last_idx = e1->icu->idx, count++, e1 = e1->next)
+ {
+ /* Verify that incoming edges are in ascending idx order. */
+ assert (count == 0 || e1->icu->idx > last_idx);
+
+ /* Verify that each incoming edge has a corresponding outgoing edge. */
+ for (e2 = e1->icu->outgoing; e2; e2 = e2->next)
+ if (e2->icu == ipu)
+ break;
+ assert (e2);
+
+ kind2 = get_node_kind (e1->icu->idx, npus, ncus);
+ verify_edge (kind2, kind, phase);
+
+ if (count == ipu->incoming_count - 1)
+ assert (ipu->incoming_tail == e1);
+ }
+
+ /* Verify the number of incoming edges. */
+ assert (ipu->incoming_count == count);
+
+ for (last_idx = 0, count = 0, e1 = ipu->outgoing;
+ e1;
+ last_idx = e1->icu->idx, count++, e1 = e1->next)
+ {
+ /* Verify that outgoing edges are in ascending idx order. */
+ assert (count == 0 || e1->icu->idx > last_idx);
+
+ /* Verify that each outgoing edge has a corresponding incoming edge. */
+ for (e2 = e1->icu->incoming; e2; e2 = e2->next)
+ if (e2->icu == ipu)
+ break;
+ assert (e2);
+
+ kind2 = get_node_kind (e1->icu->idx, npus, ncus);
+ verify_edge (kind, kind2, phase);
+ }
+
+ /* Verify the number of outgoing edges. */
+ assert (ipu->outgoing_count == count);
+
+ *ic += ipu->incoming_count;
+ *oc += ipu->outgoing_count;
+}
+
+/* Helper function for debugging create_import_tree. Call verify_edges_1
+ on all CUs and PUs. */
+static void
+verify_edges (struct import_cu **ipus, unsigned int npus, unsigned int ncus,
+ unsigned int phase)
+{
+ struct import_cu *ipu;
+ unsigned int i, ic, oc;
+
+ ic = 0;
+ oc = 0;
+
+ /* Verify initial PUs. */
+ ipu = NULL;
+ for (i = 0; i < npus; ++i)
+ {
+ ipu = ipus[i];
+ assert (ipu->cu != NULL);
+ if (i < npus - 1)
+ assert (ipu->next == ipus[i + 1]);
+ assert (ipu->incoming != NULL);
+ if (phase <= 2)
+ assert (ipu->outgoing == NULL);
+ verify_edges_1 (ipu, &ic, &oc, NODE_PU_INITIAL, npus, ncus, phase);
+ }
+
+ /* Verify new PUs. */
+ assert (ipu != NULL);
+ for (ipu = ipu->next; ipu; ipu = ipu->next)
+ {
+ assert (phase != 1);
+ assert (ipu->cu == NULL);
+ assert (ipu->incoming != NULL);
+ assert (ipu->outgoing != NULL);
+ verify_edges_1 (ipu, &ic, &oc, NODE_PU_NEW, npus, ncus, phase);
+ }
+
+ /* Verify CUs. */
+ for (i = 0; i < ncus; i++)
+ {
+ ipu = ipus[npus + i];
+ assert (ipu->cu != NULL);
+ assert (ipu->next == NULL);
+ assert (ipu->incoming == NULL);
+ assert (ipu->outgoing != NULL);
+ verify_edges_1 (ipu, &ic, &oc, NODE_CU, npus, ncus, phase);
+ }
+
+ /* Verify that the overall number of incoming and outgoing edges is
+ equal. */
+ assert (ic == oc);
+}
+
+#define BITVECTOR_TYPE unsigned int
+
+/* Return a bitvector containing NBITS bits. */
+static inline BITVECTOR_TYPE *
+bitvector_alloc (unsigned nbits)
+{
+ size_t nbytes = (nbits / 8) + 1;
+ size_t size = nbytes + sizeof (BITVECTOR_TYPE);
+ BITVECTOR_TYPE *res = (BITVECTOR_TYPE *)malloc (size);
+ if (res == NULL)
+ dwz_oom ();
+ memset (res, 0, size);
+ return res;
+}
+
+/* Set bit IDX in bitvector VECTOR. */
+static inline void FORCE_INLINE
+bitvector_set_bit (BITVECTOR_TYPE *vector, unsigned idx)
+{
+ unsigned div = idx / (sizeof (BITVECTOR_TYPE) * 8);
+ unsigned mod = idx % (sizeof (BITVECTOR_TYPE) * 8);
+ vector[div] |= (1U << mod);
+}
+
+/* Test bit IDX in bitvector VECTOR. */
+static inline bool FORCE_INLINE
+bitvector_bit_p (BITVECTOR_TYPE *vector, unsigned idx)
+{
+ unsigned div = idx / (sizeof (BITVECTOR_TYPE) * 8);
+ unsigned mod = idx % (sizeof (BITVECTOR_TYPE) * 8);
+ return (vector[div] & (1U << mod)) != 0;
+}
+
+/* Clear at least bits [A, B] in VECTOR, possibly more. */
+static inline void FORCE_INLINE
+bitvector_clear_bits (BITVECTOR_TYPE *vector, unsigned int a, unsigned int b)
+{
+ unsigned int range_min = a / (sizeof (BITVECTOR_TYPE) * 8);
+ unsigned int range_max = b / (sizeof (BITVECTOR_TYPE) * 8);
+ memset (&vector[range_min], 0,
+ (range_max - range_min + 1) * sizeof (BITVECTOR_TYPE));
+}
+
+/* Function to optimize the size of DW_TAG_imported_unit DIEs by
+ creating an inclusion tree, instead of each CU importing all
+ PUs it needs directly, by optionally creating new PUs or
+ adding DW_TAG_imported_unit to the already created PUs.
+ At the end this function constructs any new PUs needed, and
+ adds DW_TAG_imported_unit DIEs to them as well as the CUs
+ and partition_dups created PUs. */
+static int
+create_import_tree (void)
+{
+ dw_cu_ref pu, cu, last_partial_cu = NULL;
+ unsigned int i, new_pu_version = 2, min_cu_version, npus, ncus;
+ struct import_cu **ipus, *ipu, *icu;
+ unsigned int cu_off;
+ unsigned int puidx;
+ struct import_cu *last_pu, *pu_freelist = NULL;
+ unsigned char *to_free;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "create_import_tree phase 1\n");
+ }
+
+ /* size doesn't count anything already created before this
+ function (partial units etc.) or already preexisting, just
+ initially the cumulative sizes of DW_TAG_imported_unit DIEs
+ that would need to be added, and if some new DW_TAG_partial_unit
+ CUs are going to be created as a result of this routine, that size
+ too. DW_TAG_imported_unit has size 5 (for DWARF3+) or 1 + ptr_size
+ (DWARF2), DW_TAG_partial_unit has size 13/14 (11 CU header + 1 byte
+ abbrev number + 1 byte child end + 1 byte for DWARF5 unit_type). */
+ unsigned int size = 0;
+ /* Size of DW_TAG_imported_unit if the same everywhere, otherwise
+ (mixing DWARF2 and DWARF3+ with ptr_size != 4) 0. */
+ unsigned int edge_cost = 0;
+ /* Number of bytes needed for outgoing edges of PUs created by
+ this function (which all have DWARF version new_pu_version). */
+ unsigned int new_edge_cost;
+
+ /* If no PUs were created, there is nothing to do here. */
+ if (first_cu == NULL || (fi_multifile ? alt_first_cu == NULL
+ : first_cu->cu_kind != CU_PU))
+ return 0;
+
+ edge_freelist = NULL;
+ to_free = obstack_alloc (&ob2, 1);
+ min_cu_version = first_cu->cu_version;
+ /* First construct a bipartite graph between CUs and PUs. */
+ for (pu = fi_multifile ? alt_first_cu : first_cu, npus = 0;
+ pu && pu->cu_kind != CU_NORMAL; pu = pu->cu_next)
+ {
+ dw_die_ref die, rdie;
+ dw_cu_ref prev_cu;
+
+ if (pu->cu_die->die_tag == DW_TAG_compile_unit)
+ continue;
+
+ last_partial_cu = pu;
+ for (rdie = pu->cu_die->die_child;
+ rdie->die_named_namespace; rdie = rdie->die_child)
+ ;
+ if (unlikely (fi_multifile) && rdie->die_nextdup == NULL)
+ {
+ pu->u1.cu_icu = NULL;
+ continue;
+ }
+ npus++;
+ if (pu->cu_version > new_pu_version)
+ new_pu_version = pu->cu_version;
+ if (pu->cu_version < min_cu_version)
+ min_cu_version = pu->cu_version;
+ ipu = (struct import_cu *) obstack_alloc (&ob2, sizeof (*ipu));
+ memset (ipu, 0, sizeof (*ipu));
+ ipu->cu = pu;
+ pu->u1.cu_icu = ipu;
+ assert (rdie->die_toplevel);
+ dw_die_ref firstdie = NULL;
+ dw_cu_ref firstdiecu = NULL;
+ for (die = rdie->die_nextdup, prev_cu = NULL;
+ die; die = die->die_nextdup)
+ {
+ dw_cu_ref diecu = die_cu (die);
+ if (firstdie == NULL)
+ {
+ firstdie = die;
+ firstdiecu = die_cu (firstdie);
+ }
+ if (diecu == prev_cu || (die != firstdie && diecu == firstdiecu))
+ continue;
+ ipu->incoming_count++;
+ size += 1 + (diecu->cu_version == 2 ? ptr_size : 4);
+ prev_cu = diecu;
+ }
+ ipu->incoming = (struct import_edge *)
+ obstack_alloc (&ob2,
+ ipu->incoming_count
+ * sizeof (*ipu->incoming));
+ firstdie = NULL;
+ firstdiecu = NULL;
+ for (die = rdie->die_nextdup, i = 0, prev_cu = NULL;
+ die; die = die->die_nextdup)
+ {
+ dw_cu_ref diecu = die_cu (die);
+ if (firstdie == NULL)
+ {
+ firstdie = die;
+ firstdiecu = die_cu (firstdie);
+ }
+ if (diecu == prev_cu || (die != firstdie && diecu == firstdiecu))
+ continue;
+ icu = diecu->u1.cu_icu;
+ if (icu == NULL)
+ {
+ icu = (struct import_cu *)
+ obstack_alloc (&ob2, sizeof (*ipu));
+ memset (icu, 0, sizeof (*icu));
+ icu->cu = diecu;
+ diecu->u1.cu_icu = icu;
+ }
+ ipu->incoming[i++].icu = icu;
+ icu->outgoing_count++;
+ prev_cu = diecu;
+ }
+ ipu->incoming_tail = &ipu->incoming[ipu->incoming_count - 1];
+ }
+ if (npus == 0)
+ {
+ obstack_free (&ob2, to_free);
+ return 0;
+ }
+ for (cu = fi_multifile ? first_cu : pu, ncus = 0; cu; cu = cu->cu_next)
+ if (cu->u1.cu_icu)
+ {
+ ncus++;
+ if (cu->cu_version > new_pu_version)
+ new_pu_version = cu->cu_version;
+ if (cu->cu_version < min_cu_version)
+ min_cu_version = cu->cu_version;
+ cu->u1.cu_icu->outgoing
+ = (struct import_edge *)
+ obstack_alloc (&ob2,
+ cu->u1.cu_icu->outgoing_count
+ * sizeof (*cu->u1.cu_icu->outgoing));
+ cu->u1.cu_icu->outgoing_count = 0;
+ }
+ if (ptr_size == 4 || min_cu_version > 2)
+ edge_cost = 5;
+ else if (new_pu_version == 2)
+ edge_cost = 1 + ptr_size;
+ new_edge_cost = new_pu_version == 2 ? 1 + ptr_size : 5;
+ for (pu = fi_multifile ? alt_first_cu : first_cu;
+ pu && pu->cu_kind != CU_NORMAL; pu = pu->cu_next)
+ {
+ ipu = pu->u1.cu_icu;
+ if (ipu == NULL)
+ continue;
+ for (i = 0; i < ipu->incoming_count; i++)
+ {
+ icu = ipu->incoming[i].icu;
+ icu->outgoing[icu->outgoing_count++].icu = ipu;
+ }
+ }
+ ipus = (struct import_cu **)
+ obstack_alloc (&ob2, (npus + ncus) * sizeof (*ipus));
+ for (pu = fi_multifile ? alt_first_cu : first_cu, npus = 0;
+ pu && pu->cu_kind != CU_NORMAL; pu = pu->cu_next)
+ {
+ ipu = pu->u1.cu_icu;
+ if (ipu == NULL)
+ continue;
+ qsort (ipu->incoming, ipu->incoming_count, sizeof (*ipu->incoming),
+ import_edge_cmp);
+ for (i = 0; i < ipu->incoming_count; i++)
+ {
+ ipu->incoming[i].next
+ = i != ipu->incoming_count - 1 ? &ipu->incoming[i + 1] : NULL;
+ }
+ ipus[npus++] = ipu;
+ }
+ for (cu = fi_multifile ? first_cu : pu, ncus = 0; cu; cu = cu->cu_next)
+ if (cu->u1.cu_icu)
+ {
+ icu = cu->u1.cu_icu;
+ qsort (icu->outgoing, icu->outgoing_count, sizeof (*icu->outgoing),
+ import_edge_cmp);
+ for (i = 0; i < icu->outgoing_count - 1; i++)
+ icu->outgoing[i].next = &icu->outgoing[i + 1];
+ icu->outgoing[i].next = NULL;
+ ipus[npus + ncus] = icu;
+ ncus++;
+ }
+ qsort (ipus, npus, sizeof (*ipus), import_cu_cmp);
+ qsort (ipus + npus, ncus, sizeof (*ipus), import_cu_cmp);
+ for (puidx = 0; puidx < npus; puidx++)
+ {
+ ipus[puidx]->idx = puidx;
+ if (puidx + 1 < npus)
+ ipus[puidx]->next = ipus[puidx + 1];
+ }
+ for (; puidx < npus + ncus; puidx++)
+ ipus[puidx]->idx = puidx;
+ last_pu = ipus[npus - 1];
+ if (unlikely (dump_edges_p))
+ dump_edges ("phase 1", ipus, npus, ncus);
+ if (unlikely (verify_edges_p))
+ verify_edges (ipus, npus, ncus, 1);
+ if (!import_opt_p)
+ goto opt_done;
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "create_import_tree phase 2\n");
+ }
+ /* Now, for the above constructed bipartite graph, find K x,2 components
+ where x >= 5 (for DWARF3 and above or ptr_size 4, for DWARF2 and
+ ptr_size 8 it can be even x == 4) and add a new PU node, where all
+ CUs from the component will point to the new PU node and that new PU
+ will point to all the destination PUs. In theory with DWARF2
+ and ptr_size 1 we could need x >= 9.
+
+ The example below demonstrates the type of transformation. The
+ transformation is an optimization if the benefit of reducing the number
+ of imports (in other words, edges) is bigger than the cost of adding an
+ extra PU. OTOH, the transformation can be done in the presence of
+ additional incoming edges for PU_3 and PU_4.
+
+ Before: After:
+
+ CU_1---------->PU_3 CU_1 PU_3
+ \ ^ ^ \ ^
+ \ / / \ /
+ \ / / \ /
+ x----o / \ /
+ / \ / \ /
+ / \ / \ /
+ / \ / v /
+ CU_2 x CU_2----->PU_5
+ \ / \ ^ \
+ \ / \ / \
+ \ / \ / \
+ x----o \ / \
+ / \ \ / \
+ / \ \ / \
+ / v v / v
+ CU_3---------->PU_4 CU_3 PU_4
+ */
+ for (i = 0; i < npus - 1; i++)
+ {
+ struct import_cu *pudst[2], *pusrc[10];
+ struct import_edge *e1, *e2, *e3, *e4;
+ struct import_edge *e1next, *e2next, *e3next;
+ pudst[0] = ipus[i];
+ for (e1 = pudst[0]->incoming; e1; e1 = e1next)
+ {
+ e1next = e1->next;
+ if (e1->icu->cu == NULL)
+ break;
+ for (e2 = e1->icu->outgoing; e2; e2 = e2next)
+ {
+ unsigned int srccount, dstcount, cost;
+ struct import_cu *npu = NULL;
+ struct import_edge **ep = NULL;
+
+ e2next = e2->next;
+ if (e2->icu->idx <= pudst[0]->idx)
+ continue;
+ if (e2->icu->cu == NULL)
+ break;
+
+ pudst[1] = e2->icu;
+ pusrc[0] = e1->icu;
+ srccount = 1;
+ cost = edge_cost;
+ if (!edge_cost)
+ cost = pusrc[0]->cu->cu_version == 2 ? 1 + ptr_size : 5;
+ for (e3 = e1next; e3; e3 = e3next)
+ {
+ e3next = e3->next;
+ if (e3->icu->cu == NULL)
+ break;
+ dstcount = 0;
+ for (e4 = e3->icu->outgoing; e4; e4 = e4->next)
+ {
+ if (e4->icu == pudst[0])
+ dstcount++;
+ else if (e4->icu == pudst[1])
+ {
+ dstcount++;
+ break;
+ }
+ else if (e4->icu->idx > pudst[1]->idx)
+ break;
+ }
+ if (dstcount != 2)
+ continue;
+ if (npu == NULL)
+ {
+ unsigned int header_size;
+ pusrc[srccount] = e3->icu;
+ header_size = (pusrc[srccount]->cu->cu_version >= 5
+ ? 14 : 13); /* DWARF5 unit_type byte. */
+ cost += edge_cost;
+ if (!edge_cost)
+ cost += pusrc[srccount]->cu->cu_version == 2
+ ? 1 + ptr_size : 5;
+ srccount++;
+ if (ignore_size || ((dstcount - 1) * cost
+ > (header_size
+ + dstcount * new_edge_cost)))
+ {
+ unsigned int j;
+
+ e2next = NULL;
+ if (pu_freelist)
+ {
+ npu = pu_freelist;
+ pu_freelist = pu_freelist->next;
+ }
+ else
+ npu = (struct import_cu *)
+ obstack_alloc (&ob2, sizeof (*npu));
+ memset (npu, 0, sizeof (*npu));
+ npu->incoming_count = srccount;
+ npu->outgoing_count = dstcount;
+ npu->idx = puidx++;
+ last_pu->next = npu;
+ last_pu = npu;
+ for (j = 0; j < srccount; j++)
+ {
+ if (e1next && e1next->icu == pusrc[j])
+ e1next = e1next->next;
+ remove_import_edges (&pusrc[j]->outgoing, NULL,
+ pudst, dstcount, true)->icu
+ = npu;
+ pusrc[j]->outgoing_count -= dstcount - 1;
+ }
+ for (j = 0; j < dstcount; j++)
+ {
+ remove_import_edges (&pudst[j]->incoming,
+ &pudst[j]->incoming_tail,
+ pusrc, srccount, true)->icu
+ = npu;
+ pudst[j]->incoming_count -= srccount - 1;
+ }
+ npu->incoming = first_edge_from_freelist ();
+ for (j = 0, e4 = npu->incoming; j < srccount; j++)
+ {
+ e4->icu = pusrc[j];
+ if (j == srccount - 1)
+ {
+ npu->incoming
+ = last_edge_from_freelist (npu->incoming,
+ e4);
+ npu->incoming_tail = e4;
+ ep = &e4->next;
+ }
+ else
+ e4 = e4->next;
+ }
+ npu->outgoing = first_edge_from_freelist ();
+ for (j = 0, e4 = npu->outgoing; j < dstcount; j++)
+ {
+ e4->icu = pudst[j];
+ if (j == dstcount - 1)
+ npu->outgoing
+ = last_edge_from_freelist (npu->outgoing, e4);
+ else
+ e4 = e4->next;
+ }
+ size -= (dstcount - 1) * cost;
+ size += 13 + dstcount * new_edge_cost;
+ }
+ }
+ else
+ {
+ unsigned int j;
+
+ pusrc[srccount] = e3->icu;
+ cost = edge_cost;
+ if (!edge_cost)
+ cost = pusrc[srccount]->cu->cu_version == 2
+ ? 1 + ptr_size : 5;
+ if (e1next && e1next->icu == pusrc[srccount])
+ e1next = e1next->next;
+ remove_import_edges (&pusrc[srccount]->outgoing, NULL,
+ pudst, dstcount, true)->icu = npu;
+ pusrc[srccount]->outgoing_count -= dstcount - 1;
+ for (j = 0; j < dstcount; j++)
+ {
+ remove_import_edges (&pudst[j]->incoming,
+ &pudst[j]->incoming_tail,
+ pusrc + srccount, 1, false);
+ pudst[j]->incoming_count--;
+ }
+ *ep = edge_from_freelist ();
+ npu->incoming_count++;
+ (*ep)->icu = pusrc[srccount];
+ (*ep)->next = NULL;
+ npu->incoming_tail = *ep;
+ ep = &(*ep)->next;
+ size -= (dstcount - 1) * cost;
+ }
+ }
+ }
+ }
+ }
+ if (unlikely (dump_edges_p))
+ dump_edges ("phase 2", ipus, npus, ncus);
+ if (unlikely (verify_edges_p))
+ verify_edges (ipus, npus, ncus, 2);
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "create_import_tree phase 3\n");
+ }
+ /* Try to merge PUs which have the same set of referrers if
+ beneficial.
+
+ The example below demonstrates the type of transformation. The
+ transformation is an optimization because it reduces the number of import
+ statements (in other words, edges) as well as the number of PUs. It can
+ however not be done if PU_3 or PU_4 have additional incoming edges.
+
+ Before: After:
+
+ CU_1----->PU_3 CU_1
+ \ ^ \
+ \ / \
+ \ / v
+ x PU_3_4
+ / \ ^
+ / \ /
+ / v /
+ CU_2----->PU_4 CU_2
+
+ Or, if one PU has a subset of referrers of the other, attempt to replace
+ all the incoming edges from the referrers intersection to the PU with
+ larger number of incoming edges by an edge from the other PU.
+
+ The example below demonstrates the type of transformation. The
+ transformation is an optimization because it reduces the number of import
+ statements (in other words, edges). It can however not be done if PU_3
+ has additional incoming edges.
+
+ Before: After:
+
+ CU_1----->PU_3 CU_1------>PU_3
+ \ ^ ^ |
+ \ / / |
+ \ / / |
+ x / |
+ / \ / |
+ / \ / |
+ / \ / |
+ CU_2 \ CU_2 o
+ \ \ |
+ \ o |
+ \ | |
+ \ | |
+ \ | |
+ \ | |
+ v v v
+ CU_3----->PU_4 CU_3------>PU_4
+ */
+ /* Flag used during PU merging, set for PUs already considered
+ for merging for the given first PU. */
+ BITVECTOR_TYPE *seen = bitvector_alloc (puidx);
+ unsigned int min_seen = UINT_MAX;
+ unsigned int max_seen = 0;
+ for (ipu = ipus[0]; ipu; ipu = ipu->next)
+ {
+ struct import_edge *e1, *e2, *e3, *e4, **e1p, **ep, *prev;
+ for (e1p = &ipu->incoming, e1 = *e1p;
+ e1; e1 = *e1p != e1 ? *e1p : (e1p = &e1->next, e1->next))
+ {
+ for (e2 = e1->icu->outgoing; e2; e2 = e2->next)
+ {
+ unsigned int size_inc, size_dec;
+ struct import_cu *ipu2 = e2->icu, *ipusub, *ipusup;
+ /* True if IPU's src set might be a subset
+ of IPU2's src set. */
+ bool maybe_subset;
+ /* True if IPU's src set might be a superset
+ of IPU2's src set. */
+ bool maybe_superset;
+ unsigned int intersection;
+
+ if (ipu2->idx <= ipu->idx || bitvector_bit_p (seen, ipu2->idx))
+ continue;
+ bitvector_set_bit (seen, ipu2->idx);
+ min_seen = MIN (min_seen, ipu2->idx);
+ max_seen = MAX (max_seen, ipu2->idx);
+ maybe_subset = (e1 == ipu->incoming
+ && ipu->incoming_count <= ipu2->incoming_count);
+ maybe_superset = ipu->incoming_count >= ipu2->incoming_count;
+ if (maybe_superset)
+ {
+ /* If the referrer nodes of ipu are a superset of the
+ referrer nodes of ipu2, then ipu's last referrer node
+ should have index larger or equal to the last referrer
+ node of ipu2. */
+ maybe_superset
+ = (ipu->incoming_tail->icu->idx
+ >= ipu2->incoming_tail->icu->idx);
+ }
+ if (maybe_subset)
+ {
+ /* If the referrer nodes of ipu are a subset of the
+ referrer nodes of ipu2, then ipu's last referrer node
+ should have index smaller or equal to the last referrer
+ node of ipu2. */
+ maybe_subset
+ = (ipu->incoming_tail->icu->idx
+ <= ipu2->incoming_tail->icu->idx);
+ }
+ e3 = e1;
+ e4 = ipu2->incoming;
+ intersection = 0;
+ while ((maybe_subset || maybe_superset) && e3 && e4)
+ {
+ if (e3->icu == e4->icu)
+ {
+ intersection++;
+ e3 = e3->next;
+ e4 = e4->next;
+ continue;
+ }
+ if (e3->icu->idx < e4->icu->idx)
+ {
+ maybe_subset = false;
+ e3 = e3->next;
+ continue;
+ }
+ maybe_superset = false;
+ e4 = e4->next;
+ }
+ if (e3)
+ maybe_subset = false;
+ if (e4)
+ maybe_superset = false;
+ if ((!maybe_superset && !maybe_subset) || intersection < 2)
+ continue;
+ if (maybe_superset && maybe_subset)
+ {
+ if (unlikely (fi_multifile) && ipu2->idx < npus + ncus)
+ continue;
+ if (odr_active_p && odr_mode != ODR_BASIC
+ && ipu2->idx < npus + ncus)
+ continue;
+ /* If IPU and IPU2 have the same set of src nodes, then
+ (if beneficial, with edge_cost != 0 always), merge
+ IPU2 node into IPU, by removing all incoming edges
+ of IPU2 and moving over all outgoing edges of IPU2
+ to IPU. */
+ assert (ipu2->idx >= npus + ncus);
+ size_inc = 0;
+ if (edge_cost)
+ size_dec = 13 + ipu2->incoming_count * edge_cost;
+ else
+ {
+ size_dec = 13;
+ if (ipu->cu && ipu->cu->cu_version == 2)
+ {
+ if (ptr_size > 4)
+ size_inc = ipu2->outgoing_count * (ptr_size - 4);
+ else
+ size_dec += ipu2->outgoing_count * (4 - ptr_size);
+ }
+ for (e4 = ipu2->incoming; e4; e4 = e4->next)
+ size_dec += (e4->icu->cu
+ && e4->icu->cu->cu_version == 2)
+ ? 1 + ptr_size : 5;
+ }
+ if (!ignore_size || size_dec > size_inc)
+ {
+ struct import_cu **ipup;
+ for (e4 = ipu2->incoming, e3 = NULL; e4; e4 = e4->next)
+ {
+ remove_import_edges (&e4->icu->outgoing, NULL, &ipu2,
+ 1, false);
+ e4->icu->outgoing_count--;
+ prepare_free_edge (e4);
+ e3 = e4;
+ }
+ free_edges (ipu2->incoming, e3);
+ for (e4 = ipu2->outgoing; e4; e4 = e4->next)
+ {
+ for (ep = &e4->icu->incoming; *ep; ep = &(*ep)->next)
+ if ((*ep)->icu->idx >= ipu->idx)
+ break;
+ assert ((*ep)->icu != ipu);
+ if ((*ep)->icu == ipu2)
+ (*ep)->icu = ipu;
+ else
+ {
+ struct import_edge **ep2;
+ for (ep2 = &(*ep)->next;
+ *ep2; ep2 = &(*ep2)->next)
+ if ((*ep2)->icu == ipu2)
+ break;
+ e3 = *ep2;
+ *ep2 = e3->next;
+ e3->next = *ep;
+ *ep = e3;
+ e3->icu = ipu;
+ while (e4->icu->incoming_tail->next != NULL)
+ e4->icu->incoming_tail
+ = e4->icu->incoming_tail->next;
+ }
+ }
+ e3 = ipu->outgoing;
+ ep = &ipu->outgoing;
+ for (e4 = ipu2->outgoing; e3 && e4; )
+ if (e3->icu->idx < e4->icu->idx)
+ {
+ *ep = e3;
+ ep = &e3->next;
+ e3 = e3->next;
+ }
+ else
+ {
+ assert (e3->icu != e4->icu);
+ *ep = e4;
+ ep = &e4->next;
+ e4 = e4->next;
+ }
+ if (e3)
+ *ep = e3;
+ else if (e4)
+ *ep = e4;
+ else
+ *ep = NULL;
+ ipu->outgoing_count += ipu2->outgoing_count;
+ size -= size_dec - size_inc;
+ if (ipu->idx >= npus + ncus)
+ ipup = &ipu->next;
+ else
+ ipup = &ipus[npus - 1]->next;
+ while (*ipup != ipu2)
+ ipup = &(*ipup)->next;
+ *ipup = ipu2->next;
+ ipu2->next = pu_freelist;
+ pu_freelist = ipu2;
+ continue;
+ }
+ }
+ if (maybe_superset)
+ {
+ ipusup = ipu;
+ ipusub = ipu2;
+ }
+ else
+ {
+ ipusub = ipu;
+ ipusup = ipu2;
+ }
+ /* If IPUSUB's src set is a subset of IPUSUP's src set
+ and intersection is at least 2, remove edges from
+ IPUSUB's src set to IPUSUP node and instead add
+ an edge from IPUSUB to IPUSUP. */
+ size_inc = 0;
+ if (edge_cost)
+ size_dec = (ipusub->incoming_count - 1) * edge_cost;
+ else
+ {
+ size_inc = ipusub->cu && ipusub->cu->cu_version == 2
+ ? 1 + ptr_size : 5;
+ size_dec = 0;
+ for (e3 = ipusub->incoming; e3; e3 = e3->next)
+ size_dec += (e3->icu->cu
+ && e3->icu->cu->cu_version == 2)
+ ? 1 + ptr_size : 5;
+ }
+ if (size_dec > size_inc
+ && (!fi_multifile || ipusub->idx >= npus + ncus))
+ {
+ for (e3 = ipusub->incoming, ep = &ipusup->incoming,
+ prev = NULL;
+ e3; e3 = e3->next)
+ {
+ remove_import_edges (&e3->icu->outgoing, NULL, &ipusup, 1,
+ false);
+ e3->icu->outgoing_count--;
+ while ((*ep)->icu != e3->icu)
+ {
+ prev = *ep;
+ ep = &(*ep)->next;
+ }
+ e4 = *ep;
+ *ep = e4->next;
+ free_edge (e4);
+ if (ipusup->incoming_tail == e4)
+ ipusup->incoming_tail = prev;
+ }
+ for (ep = &ipusub->outgoing; *ep; ep = &(*ep)->next)
+ if ((*ep)->icu->idx >= ipusup->idx)
+ break;
+ assert (*ep == NULL || (*ep)->icu != ipusup);
+ e4 = edge_from_freelist ();
+ e4->icu = ipusup;
+ e4->next = *ep;
+ *ep = e4;
+ ipusub->outgoing_count++;
+ for (ep = &ipusup->incoming; *ep; ep = &(*ep)->next)
+ if ((*ep)->icu->idx >= ipusub->idx)
+ break;
+ assert (*ep == NULL || (*ep)->icu != ipusub);
+ e4 = edge_from_freelist ();
+ e4->icu = ipusub;
+ e4->next = *ep;
+ *ep = e4;
+ if (ipusup->incoming_tail->next == e4)
+ ipusup->incoming_tail = e4;
+ ipusup->incoming_count -= ipusub->incoming_count - 1;
+ size -= size_dec - size_inc;
+ if (ipusup == ipu)
+ break;
+ }
+ }
+ }
+ if (min_seen <= max_seen)
+ {
+ bitvector_clear_bits (seen, min_seen, max_seen);
+ min_seen = UINT_MAX;
+ max_seen = 0;
+ }
+ }
+ free (seen);
+ if (unlikely (dump_edges_p))
+ dump_edges ("phase 3", ipus, npus, ncus);
+ if (unlikely (verify_edges_p))
+ verify_edges (ipus, npus, ncus, 3);
+ opt_done:
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "create_import_tree phase 4 (create partial units)\n");
+ }
+ /* Create DW_TAG_partial_unit (and containing dw_cu structures). */
+ if (fi_multifile)
+ {
+ cu_off = 0;
+ last_partial_cu = NULL;
+ }
+ else
+ cu_off = last_partial_cu->cu_offset + 1;
+ for (ipu = ipus[npus - 1]->next; ipu; ipu = ipu->next)
+ {
+ dw_die_ref die;
+ dw_cu_ref partial_cu = pool_alloc (dw_cu, sizeof (struct dw_cu));
+ memset (partial_cu, '\0', sizeof (*partial_cu));
+ partial_cu->cu_kind = CU_PU;
+ partial_cu->cu_offset = cu_off++;
+ partial_cu->cu_version = new_pu_version;
+ partial_cu->u1.cu_icu = ipu;
+ if (unlikely (last_partial_cu == NULL))
+ {
+ partial_cu->cu_next = first_cu;
+ first_cu = partial_cu;
+ }
+ else
+ {
+ partial_cu->cu_next = last_partial_cu->cu_next;
+ last_partial_cu->cu_next = partial_cu;
+ }
+ last_partial_cu = partial_cu;
+ die = pool_alloc (dw_die, sizeof (struct dw_die));
+ memset (die, '\0', sizeof (struct dw_die));
+ die->die_toplevel = 1;
+ partial_cu->cu_die = die;
+ die->die_tag = DW_TAG_partial_unit;
+ die->die_offset = -1U;
+ die->die_root = 1;
+ die->die_parent = (dw_die_ref) partial_cu;
+ die->die_size = 1;
+ ipu->cu = partial_cu;
+ }
+ /* Next add all needed DW_TAG_imported_unit DIEs. */
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ {
+ struct import_edge *e;
+
+ icu = cu->u1.cu_icu;
+ if (icu == NULL)
+ continue;
+ for (e = icu->outgoing; e; e = e->next)
+ {
+ dw_die_ref *diep;
+ dw_die_ref die = pool_alloc (dw_die, sizeof (struct dw_die));
+ memset (die, '\0', sizeof (*die));
+ die->die_toplevel = 1;
+ die->die_tag = DW_TAG_imported_unit;
+ die->die_offset = -1U;
+ die->die_nextdup = e->icu->cu->cu_die;
+ die->die_parent = cu->cu_die;
+ assert (e->icu->cu->cu_die->die_tag == DW_TAG_partial_unit);
+ die->die_size = (cu->cu_version == 2 ? 1 + ptr_size : 5);
+ /* Put the new DW_TAG_imported_unit DIE after all typed DWARF
+ stack referenced base types and after all previously added
+ new DW_TAG_imported_unit DIEs. */
+ for (diep = &die->die_parent->die_child;
+ *diep; diep = &(*diep)->die_sib)
+ if (!(*diep)->die_op_type_referenced
+ && ((*diep)->die_tag != DW_TAG_imported_unit
+ || (*diep)->die_offset != -1U))
+ break;
+ die->die_sib = *diep;
+ *diep = die;
+ }
+ }
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ cu->u1.cu_icu = NULL;
+ if (unlikely (fi_multifile))
+ for (cu = alt_first_cu; cu; cu = cu->cu_next)
+ cu->u1.cu_icu = NULL;
+ obstack_free (&ob2, to_free);
+ return 0;
+}
+
+/* Helper function for die_find_dup, when ORIG has collapsed children. */
+static dw_die_ref
+die_find_collapsed_dup (dw_die_ref die, unsigned int *tick)
+{
+ dw_die_ref child, ret;
+
+ for (child = die->die_child; child; child = child->die_sib)
+ if ((*tick)-- == 0)
+ return child;
+ else if (child->die_child == NULL)
+ continue;
+ else if ((ret = die_find_collapsed_dup (child, tick)) != NULL)
+ return ret;
+ (*tick)--;
+ return NULL;
+}
+
+/* If DIE is equal to ORIG, return DUP, otherwise if DIE is
+ a child of ORIG, return corresponding child in DUP's subtree,
+ or return NULL. */
+static dw_die_ref
+die_find_dup (dw_die_ref orig, dw_die_ref dup, dw_die_ref die)
+{
+ dw_die_ref orig_child, dup_child;
+ if (orig == die)
+ return dup;
+ if (orig->die_collapsed_children)
+ {
+ dw_die_ref ret;
+ unsigned int tick;
+ if (die->die_collapsed_child)
+ tick = die->die_tag - 1;
+ else
+ tick = die->die_ref_seen - 1;
+ assert (dup->die_collapsed_children == 0
+ && die->die_parent == orig);
+ ret = die_find_collapsed_dup (dup, &tick);
+ assert (die->die_collapsed_child || ret->die_tag == die->die_tag);
+ return ret;
+ }
+ for (orig_child = orig->die_child, dup_child = dup->die_child;
+ orig_child;
+ orig_child = orig_child->die_sib, dup_child = dup_child->die_sib)
+ {
+ dw_die_ref ret = die_find_dup (orig_child, dup_child, die);
+ if (ret)
+ return ret;
+ }
+ return NULL;
+}
+
+/* Return number of bytes needed to encode VAL using
+ uleb128. */
+static unsigned int
+size_of_uleb128 (uint64_t val)
+{
+ unsigned int size;
+ for (size = 1; (val >>= 7) != 0; size++)
+ ;
+ return size;
+}
+
+/* Return number of bytes needed to encode VAL using
+ sleb128. */
+static unsigned int
+size_of_sleb128 (int64_t val)
+{
+ unsigned int size = 0;
+ unsigned char c;
+ do
+ {
+ c = val & 0x7f;
+ val >>= 7;
+ size++;
+ }
+ while ((val != 0 || (c & 0x40) != 0)
+ && (val != -1 || (c & 0x40) == 0));
+ return size;
+}
+
+/* Hash table mapping original file IDs to new ids. */
+static htab_t line_htab;
+/* Current new maximum file ID. */
+static unsigned int max_line_id;
+
+struct line_entry
+{
+ /* File pointer. */
+ struct dw_file *file;
+ /* Precomputed hash value. */
+ unsigned int hash;
+ /* Corresponding new file ID. */
+ unsigned int new_id;
+};
+ALIGN_STRUCT (line_entry)
+
+/* Hash function in line_htab. */
+static hashval_t
+line_hash (const void *p)
+{
+ struct line_entry *s = (struct line_entry *)p;
+
+ return s->hash;
+}
+
+/* Equality function in line_htab. */
+static int
+line_eq (const void *p, const void *q)
+{
+ struct line_entry *s1 = (struct line_entry *)p;
+ struct line_entry *s2 = (struct line_entry *)q;
+
+ if (s1->hash != s2->hash)
+ return 0;
+ if (s1->file == s2->file)
+ return 1;
+ if (strcmp (s1->file->file, s2->file->file) != 0)
+ return 0;
+ if ((s1->file->dir == NULL) ^ (s2->file->dir == NULL))
+ return 0;
+ if (s1->file->dir && strcmp (s1->file->dir, s2->file->dir) != 0)
+ return 0;
+ return s1->file->time == s2->file->time && s1->file->size == s2->file->size;
+}
+
+/* Map original file ID to new file ID. */
+static unsigned int
+line_htab_lookup (dw_cu_ref cu, unsigned int id)
+{
+ void **slot;
+ struct line_entry le;
+ if (id == 0)
+ return 0;
+ assert (id <= cu->cu_nfiles);
+ le.file = &cu->cu_files[id - 1];
+ hash_init_state ();
+ hash_update_state_object (le.file->time);
+ hash_update_state_object (le.file->size);
+ hash_update_state (le.file->file, strlen (le.file->file) + 1);
+ if (le.file->dir)
+ hash_update_state (le.file->dir, strlen (le.file->dir) + 1);
+ if (line_htab == NULL)
+ {
+ line_htab = htab_try_create (50, line_hash, line_eq, NULL);
+ if (line_htab == NULL)
+ dwz_oom ();
+ max_line_id = 1;
+ }
+ le.hash = hash_digest ();
+ slot = htab_find_slot_with_hash (line_htab, &le, le.hash, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot == NULL)
+ {
+ struct line_entry *l = pool_alloc (line_entry, sizeof (*l));
+ l->file = le.file;
+ l->hash = le.hash;
+ l->new_id = max_line_id++;
+ *slot = (void *) l;
+ return l->new_id;
+ }
+ else
+ return ((struct line_entry *) *slot)->new_id;
+}
+
+/* Hash table for finding duplicate .debug_macro opcode sequences.
+ This hash table is used with two different sets of hash/equality
+ callbacks. One is used either within handle_macro function (from within
+ optimize_multifile), or from handle_macro onwards (read_multifile).
+ The second set is used from read_macro onwards during fi_multifile. */
+static htab_t macro_htab;
+
+/* At the end of read_multifile macro_htab is copied to this variable. */
+static htab_t alt_macro_htab;
+
+struct macro_entry
+{
+ /* Start of the sequence. */
+ unsigned char *ptr;
+ /* Precomputed hash value. LSB bit is used for a flag whether
+ a particular .debug_macro sequence is seen more than once. */
+ unsigned int hash;
+ /* And it's length or 0 if non-shareable. */
+ unsigned int len;
+};
+ALIGN_STRUCT (macro_entry)
+
+/* Hash function in macro_htab. */
+static hashval_t
+macro_hash (const void *p)
+{
+ struct macro_entry *m = (struct macro_entry *)p;
+
+ return m->hash & ~1U;
+}
+
+/* Equality function in macro_htab. */
+static int
+macro_eq (const void *p, const void *q)
+{
+ struct macro_entry *m1 = (struct macro_entry *)p;
+ struct macro_entry *m2 = (struct macro_entry *)q;
+ unsigned char *p1, *p2, *s1, op;
+ unsigned int strp1, strp2;
+
+ if (m1->hash != m2->hash || m1->len != m2->len)
+ return 0;
+ if (rd_multifile)
+ return 0;
+
+ s1 = m1->ptr;
+ p2 = m2->ptr;
+ p1 = s1 + 3;
+
+ while (1)
+ {
+ op = read_8 (p1);
+ if (op == 0)
+ break;
+
+ switch (op)
+ {
+ case DW_MACRO_define:
+ case DW_MACRO_undef:
+ skip_leb128 (p1);
+ p1 = (unsigned char *) strchr ((char *) p1, '\0') + 1;
+ break;
+ case DW_MACRO_define_strp:
+ case DW_MACRO_undef_strp:
+ skip_leb128 (p1);
+ if (memcmp (s1, p2, p1 - s1) != 0)
+ return 0;
+ p2 += p1 - s1;
+ strp1 = read_32 (p1);
+ strp2 = read_32 (p2);
+ if (op_multifile)
+ {
+ if (strcmp ((char *) debug_sections[DEBUG_STR].data + strp1,
+ (char *) debug_sections[DEBUG_STR].data + strp2)
+ != 0)
+ return 0;
+ }
+ else if (lookup_strp_offset (strp2) != strp1)
+ return 0;
+ s1 = p1;
+ break;
+ default:
+ abort ();
+ }
+ }
+ return memcmp (s1, p2, p1 - s1) == 0;
+}
+
+/* Hash function in macro_htab. */
+static hashval_t
+macro_hash2 (const void *p)
+{
+ struct macro_entry *m = (struct macro_entry *)p;
+
+ return m->ptr - debug_sections[DEBUG_MACRO].data;
+}
+
+/* Equality function in macro_htab. */
+static int
+macro_eq2 (const void *p, const void *q)
+{
+ struct macro_entry *m1 = (struct macro_entry *)p;
+ struct macro_entry *m2 = (struct macro_entry *)q;
+ return m1->ptr == m2->ptr;
+}
+
+/* Parse .debug_macro section, either during write_multifile
+ or during fi_multifile phase. During write_multifile it
+ selects potentially shareable .debug_macro sequences and
+ writes them into debug_sections[DEBUG_MACRO].new_data
+ block it allocates. During fi_multifile it populates
+ macro_htab. In both cases it calls note_strp_offset
+ on DW_FORM_strp offsets. */
+static int
+read_macro (DSO *dso)
+{
+ unsigned char *ptr, *endsec, *dst = NULL;
+ unsigned int version, flags, op, strp;
+ struct macro_entry me, *m;
+
+ ptr = debug_sections[DEBUG_MACRO].data;
+ endsec = ptr + debug_sections[DEBUG_MACRO].size;
+ debug_sections[DEBUG_MACRO].new_size = 0;
+ if (!wr_multifile)
+ {
+ macro_htab = htab_try_create (50, macro_hash2, macro_eq2, NULL);
+ if (macro_htab == NULL)
+ dwz_oom ();
+ }
+
+ while (ptr < endsec)
+ {
+ unsigned char *start = ptr, *s = ptr;
+ bool can_share = true;
+ hashval_t hash = 0;
+ unsigned int strp;
+ void **slot;
+
+ if (ptr + 4 > endsec)
+ {
+ error (0, 0, "%s: .debug_macro header too small", dso->filename);
+ return 1;
+ }
+
+ version = read_16 (ptr);
+ bool supported_version_p = version >= 4 && version <= 5;
+ if (!supported_version_p)
+ {
+ error (0, 0, "%s: Unhandled .debug_macro version %d", dso->filename,
+ version);
+ return 1;
+ }
+ flags = read_8 (ptr);
+ if ((flags & ~2U) != 0)
+ {
+ error (0, 0, "%s: Unhandled .debug_macro flags %d", dso->filename,
+ flags);
+ return 1;
+ }
+ if ((flags & 2) != 0)
+ {
+ ptr += 4;
+ can_share = false;
+ }
+ if (fi_multifile && alt_macro_htab == NULL)
+ can_share = false;
+
+ op = -1U;
+ while (ptr < endsec)
+ {
+ op = read_8 (ptr);
+ if (op == 0)
+ break;
+
+ switch (op)
+ {
+ case DW_MACRO_define:
+ case DW_MACRO_undef:
+ skip_leb128 (ptr);
+ ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+ break;
+ case DW_MACRO_start_file:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ can_share = false;
+ break;
+ case DW_MACRO_end_file:
+ can_share = false;
+ break;
+ case DW_MACRO_define_strp:
+ case DW_MACRO_undef_strp:
+ skip_leb128 (ptr);
+ strp = read_32 (ptr);
+ note_strp_offset (strp);
+ if (wr_multifile)
+ break;
+ if (can_share)
+ hash = iterative_hash (s, ptr - 4 - s, hash);
+ if (can_share)
+ {
+ unsigned char *p = debug_sections[DEBUG_STR].data + strp;
+ unsigned int len = strlen ((char *) p);
+ hash = iterative_hash (p, len, hash);
+ s = ptr;
+ }
+ break;
+ case DW_MACRO_import:
+ ptr += 4;
+ can_share = false;
+ break;
+ default:
+ error (0, 0, "%s: Unhandled .debug_macro opcode 0x%x",
+ dso->filename, op);
+ return 1;
+ }
+ }
+ if (op != 0)
+ {
+ error (0, 0, "%s: .debug_macro section not zero terminated",
+ dso->filename);
+ return 1;
+ }
+ if (wr_multifile)
+ {
+ if (can_share)
+ debug_sections[DEBUG_MACRO].new_size += ptr - start;
+ continue;
+ }
+
+ me.ptr = start;
+ if (can_share)
+ {
+ hash = iterative_hash (s, ptr - s, hash);
+ me.hash = hash & ~1U;
+ me.len = ptr - start;
+ m = (struct macro_entry *)
+ htab_find_with_hash (alt_macro_htab, &me, me.hash);
+ if (m == NULL)
+ can_share = false;
+ else
+ me.hash = m->ptr - alt_data[DEBUG_MACRO];
+ }
+ if (!can_share)
+ {
+ me.len = 0;
+ me.hash = debug_sections[DEBUG_MACRO].new_size;
+ debug_sections[DEBUG_MACRO].new_size += ptr - start;
+ }
+ slot
+ = htab_find_slot_with_hash (macro_htab, &me,
+ me.ptr - debug_sections[DEBUG_MACRO].data,
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ else
+ {
+ assert (*slot == NULL);
+ m = pool_alloc (macro_entry, sizeof (*m));
+ *m = me;
+ *slot = (void *) m;
+ }
+ }
+
+ if (!wr_multifile)
+ return 0;
+
+ debug_sections[DEBUG_MACRO].new_data
+ = (unsigned char *) malloc (debug_sections[DEBUG_MACRO].new_size);
+ if (debug_sections[DEBUG_MACRO].new_data == NULL)
+ dwz_oom ();
+ dst = debug_sections[DEBUG_MACRO].new_data;
+ for (ptr = debug_sections[DEBUG_MACRO].data; ptr < endsec; )
+ {
+ unsigned char *start = ptr;
+ bool can_share = true;
+
+ ptr += 2;
+ flags = read_8 (ptr);
+ if ((flags & 2) != 0)
+ {
+ ptr += 4;
+ can_share = false;
+ }
+
+ while (1)
+ {
+ op = read_8 (ptr);
+ if (op == 0)
+ break;
+
+ switch (op)
+ {
+ case DW_MACRO_define:
+ case DW_MACRO_undef:
+ skip_leb128 (ptr);
+ ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+ break;
+ case DW_MACRO_start_file:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ can_share = false;
+ break;
+ case DW_MACRO_end_file:
+ can_share = false;
+ break;
+ case DW_MACRO_define_strp:
+ case DW_MACRO_undef_strp:
+ skip_leb128 (ptr);
+ ptr += 4;
+ break;
+ case DW_MACRO_import:
+ ptr += 4;
+ can_share = false;
+ break;
+ default:
+ abort ();
+ }
+ }
+ if (can_share)
+ {
+ ptr = start + 3;
+
+ while (1)
+ {
+ op = read_8 (ptr);
+ if (op == 0)
+ break;
+
+ switch (op)
+ {
+ case DW_MACRO_define:
+ case DW_MACRO_undef:
+ skip_leb128 (ptr);
+ ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+ break;
+ case DW_MACRO_define_strp:
+ case DW_MACRO_undef_strp:
+ skip_leb128 (ptr);
+ memcpy (dst, start, ptr - start);
+ dst += ptr - start;
+ strp = lookup_strp_offset (read_32 (ptr));
+ write_32 (dst, strp);
+ start = ptr;
+ break;
+ default:
+ abort ();
+ }
+ }
+ memcpy (dst, start, ptr - start);
+ dst += ptr - start;
+ }
+ }
+ assert (dst == debug_sections[DEBUG_MACRO].new_data
+ + debug_sections[DEBUG_MACRO].new_size);
+
+ return 0;
+}
+
+/* Helper function for handle_macro, called through htab_traverse.
+ Write .debug_macro opcode sequence seen by more than one
+ executable or shared library. */
+static int
+optimize_write_macro (void **slot, void *data)
+{
+ struct macro_entry *m = (struct macro_entry *) *slot;
+ unsigned char **pp = (unsigned char **) data;
+ unsigned char *s = m->ptr;
+ unsigned char *p = s + 3, *q, op;
+ unsigned int strp;
+
+ if ((m->hash & 1) == 0)
+ return 1;
+ while (1)
+ {
+ op = read_8 (p);
+ if (op == 0)
+ break;
+
+ switch (op)
+ {
+ case DW_MACRO_define:
+ case DW_MACRO_undef:
+ skip_leb128 (p);
+ p = (unsigned char *) strchr ((char *) p, '\0') + 1;
+ break;
+ case DW_MACRO_define_strp:
+ case DW_MACRO_undef_strp:
+ skip_leb128 (p);
+ memcpy (*pp, s, p - s);
+ *pp += p - s;
+ strp = read_32 (p);
+ q = *pp;
+ write_32 (q, lookup_strp_offset (strp));
+ *pp += 4;
+ s = p;
+ break;
+ default:
+ abort ();
+ }
+ }
+ memcpy (*pp, s, p - s);
+ *pp += p - s;
+ return 1;
+}
+
+/* Parse .debug_macro section, during optimize_multifile
+ or during read_multifile. It parses .debug_macro written
+ by write_multifile, so it only contains shareable sequences.
+ Find duplicate sequences, during optimize_multifile write them
+ into debug_sections[DEBUG_MACRO].new_data it allocates,
+ during read_multifile just populates macro_htab (soon to be
+ alt_macro_htab). */
+static void
+handle_macro (void)
+{
+ unsigned char *ptr, *endsec, op;
+ unsigned char *to_free = NULL;
+ struct macro_entry me, *m;
+
+ macro_htab = htab_try_create (50, macro_hash, macro_eq, NULL);
+ if (macro_htab == NULL)
+ dwz_oom ();
+
+ endsec = debug_sections[DEBUG_MACRO].data + debug_sections[DEBUG_MACRO].size;
+ if (op_multifile)
+ {
+ debug_sections[DEBUG_MACRO].new_size = 0;
+ to_free = obstack_alloc (&ob, 1);
+ }
+
+ for (ptr = debug_sections[DEBUG_MACRO].data; ptr < endsec; )
+ {
+ unsigned char *start = ptr, *s = ptr, *p;
+ hashval_t hash = 0;
+ unsigned int len;
+ void **slot;
+ bool can_share = true;
+
+ ptr += 3;
+ while (1)
+ {
+ op = read_8 (ptr);
+ if (op == 0)
+ break;
+
+ switch (op)
+ {
+ case DW_MACRO_define:
+ case DW_MACRO_undef:
+ skip_leb128 (ptr);
+ ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+ break;
+ case DW_MACRO_define_strp:
+ case DW_MACRO_undef_strp:
+ skip_leb128 (ptr);
+ hash = iterative_hash (s, ptr - s, hash);
+ p = debug_sections[DEBUG_STR].data + read_32 (ptr);
+ len = strlen ((char *) p);
+ hash = iterative_hash (p, len, hash);
+ if (op_multifile
+ /* This should only happen if there were multiple
+ same transparent units within a single object file. */
+ && htab_find_with_hash (strp_htab, p,
+ hash (p, len)) == NULL)
+ can_share = false;
+ s = ptr;
+ break;
+ default:
+ abort ();
+ }
+ }
+ if (!can_share)
+ continue;
+ hash = iterative_hash (s, ptr - s, hash);
+ me.ptr = start;
+ me.hash = hash & ~1U;
+ me.len = ptr - start;
+ slot = htab_find_slot_with_hash (macro_htab, &me, me.hash, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ else if (*slot != NULL)
+ {
+ m = (struct macro_entry *) *slot;
+ if (op_multifile && (m->hash & 1) == 0)
+ {
+ m->hash |= 1;
+ debug_sections[DEBUG_MACRO].new_size += me.len;
+ }
+ }
+ else if (op_multifile)
+ {
+ m = (struct macro_entry *) obstack_alloc (&ob, sizeof (*m));
+ *m = me;
+ *slot = (void *) m;
+ }
+ else
+ {
+ m = pool_alloc (macro_entry, sizeof (*m));
+ *m = me;
+ *slot = (void *) m;
+ }
+ }
+
+ if (op_multifile)
+ {
+ if (debug_sections[DEBUG_MACRO].new_size)
+ {
+ unsigned char *p;
+ debug_sections[DEBUG_MACRO].new_data
+ = malloc (debug_sections[DEBUG_MACRO].new_size);
+ p = debug_sections[DEBUG_MACRO].new_data;
+ htab_traverse (macro_htab, optimize_write_macro, &p);
+ assert (p == debug_sections[DEBUG_MACRO].new_data
+ + debug_sections[DEBUG_MACRO].new_size);
+ htab_delete (macro_htab);
+ macro_htab = NULL;
+ }
+ obstack_free (&ob, (void *) to_free);
+ }
+}
+
+/* Write new content of .debug_macro section during fi_multifile phase. */
+static void
+write_macro (void)
+{
+ unsigned char *ptr, *endsec, *dst;
+ unsigned int op, strp;
+ struct macro_entry me, *m;
+
+ endsec = debug_sections[DEBUG_MACRO].data + debug_sections[DEBUG_MACRO].size;
+ debug_sections[DEBUG_MACRO].new_data
+ = (unsigned char *) malloc (debug_sections[DEBUG_MACRO].new_size);
+ if (debug_sections[DEBUG_MACRO].new_data == NULL)
+ dwz_oom ();
+ dst = debug_sections[DEBUG_MACRO].new_data;
+ for (ptr = debug_sections[DEBUG_MACRO].data; ptr < endsec; )
+ {
+ unsigned char *s = ptr;
+ unsigned char flags;
+
+ me.ptr = ptr;
+ m = (struct macro_entry *)
+ htab_find_with_hash (macro_htab, &me,
+ me.ptr - debug_sections[DEBUG_MACRO].data);
+ if (m->len)
+ {
+ ptr += m->len;
+ continue;
+ }
+
+ ptr += 2;
+ flags = read_8 (ptr);
+ if ((flags & 2) != 0)
+ ptr += 4;
+
+ while (1)
+ {
+ op = read_8 (ptr);
+ if (op == 0)
+ break;
+
+ switch (op)
+ {
+ case DW_MACRO_define:
+ case DW_MACRO_undef:
+ skip_leb128 (ptr);
+ ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
+ break;
+ case DW_MACRO_start_file:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ break;
+ case DW_MACRO_end_file:
+ break;
+ case DW_MACRO_define_strp:
+ case DW_MACRO_undef_strp:
+ memcpy (dst, s, ptr - 1 - s);
+ dst += ptr - 1 - s;
+ s = ptr - 1;
+ skip_leb128 (ptr);
+ strp = read_32 (ptr);
+ switch (note_strp_offset2 (strp))
+ {
+ case DW_FORM_GNU_strp_alt:
+ case DW_FORM_strp_sup:
+ *dst = op == DW_MACRO_define_strp
+ ? DW_MACRO_define_sup
+ : DW_MACRO_undef_sup;
+ dst++;
+ s++;
+ break;
+ default:
+ break;
+ }
+ memcpy (dst, s, ptr - 4 - s);
+ dst += ptr - 4 - s;
+ write_32 (dst, lookup_strp_offset (strp));
+ s = ptr;
+ break;
+ case DW_MACRO_import:
+ memcpy (dst, s, ptr - 1 - s);
+ dst += ptr - 1 - s;
+ me.ptr = debug_sections[DEBUG_MACRO].data + read_32 (ptr);
+ m = (struct macro_entry *)
+ htab_find_with_hash (macro_htab, &me,
+ me.ptr
+ - debug_sections[DEBUG_MACRO].data);
+ if (m->len)
+ *dst = DW_MACRO_import_sup;
+ else
+ *dst = DW_MACRO_import;
+ dst++;
+ write_32 (dst, m->hash);
+ s = ptr;
+ break;
+ default:
+ abort ();
+ }
+ }
+ memcpy (dst, s, ptr - s);
+ dst += ptr - s;
+ }
+ assert (dst == debug_sections[DEBUG_MACRO].new_data
+ + debug_sections[DEBUG_MACRO].new_size);
+}
+
+/* Compute new abbreviations for DIE (with reference DIE REF).
+ T is a temporary buffer. Fill in *NDIES - number of DIEs
+ in the tree, and record pairs of referrer/referree DIEs for
+ intra-CU references into obstack vector VEC. */
+static int
+build_abbrevs_for_die (htab_t h, dw_cu_ref cu, dw_die_ref die,
+ dw_cu_ref refcu, dw_die_ref ref,
+ struct abbrev_tag *t, unsigned int *ndies,
+ struct obstack *vec, bool recompute)
+{
+ dw_die_ref child, ref_child, sib = NULL, origin = NULL;
+ unsigned int i, j;
+ uint64_t low_pc = 0;
+ void **slot;
+
+ if (unlikely (recompute) && die->u.p2.die_new_abbrev != NULL)
+ {
+ if (cu->cu_intracu_form == DW_FORM_ref_udata)
+ die->die_ref_seen = 1;
+ else
+ {
+ die->die_size -= size_of_uleb128 (die->u.p2.die_new_abbrev->entry)
+ + die->u.p2.die_intracu_udata_size;
+ die->die_ref_seen = 0;
+ }
+ for (child = die->die_child; child; child = child->die_sib)
+ if (build_abbrevs_for_die (h, cu, child, NULL, NULL, t, ndies, vec,
+ true))
+ return 1;
+ return 0;
+ }
+
+ die->u.p2.die_new_abbrev = NULL;
+ die->u.p2.die_new_offset = 0;
+ die->u.p2.die_intracu_udata_size = 0;
+ die->die_ref_seen = 0;
+
+ if (wr_multifile ? die->die_no_multifile : die->die_remove)
+ return 0;
+ t->entry = 0;
+ t->tag = die->die_tag;
+ t->children = die->die_child != NULL;
+ t->op_type_referenced = false;
+ t->nusers = 1;
+ if (die->die_offset == -1U)
+ {
+ if (ref != NULL)
+ ;
+ else if (die_safe_nextdup (die) && die->die_nextdup->die_dup == die)
+ {
+ ref = die->die_nextdup;
+ if (ref != NULL)
+ refcu = die_cu (ref);
+ }
+ if (ref == NULL)
+ origin = die->die_nextdup;
+ }
+ else
+ {
+ ref = die;
+ refcu = cu;
+ if (wr_multifile
+ && (die->die_root || die->die_named_namespace))
+ origin = die;
+ }
+ if (die->die_child && die->die_sib)
+ for (sib = die->die_sib; sib; sib = sib->die_sib)
+ if (wr_multifile ? !sib->die_no_multifile : !sib->die_remove)
+ break;
+ if (ref != NULL && origin == NULL)
+ {
+ unsigned char *base
+ = cu->cu_kind == CU_TYPES
+ ? debug_sections[DEBUG_TYPES].data
+ : debug_sections[DEBUG_INFO].data;
+ unsigned char *ptr = base + ref->die_offset;
+ struct abbrev_tag *reft = ref->die_abbrev;
+
+ skip_leb128 (ptr);
+ /* No longer count the abbrev uleb128 size in die_size.
+ We'll add it back after determining the new abbrevs. */
+ if (unlikely (wr_multifile || op_multifile || fi_multifile)
+ || unlikely (recompute))
+ i = -1U;
+ else
+ for (i = 0; i < reft->nattr; i++)
+ switch (reft->attr[i].form)
+ {
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_ref_udata:
+ case DW_FORM_indirect:
+ i = -2U;
+ break;
+ case DW_FORM_data4:
+ case DW_FORM_data8:
+ if (reft->attr[i].attr == DW_AT_high_pc)
+ i = -2U;
+ break;
+ case DW_FORM_addr:
+ if (reft->attr[i].attr == DW_AT_high_pc
+ && cu->cu_version >= 4)
+ i = -2U;
+ break;
+ default:
+ break;
+ }
+ if (i != -1U)
+ {
+ die->die_size -= ptr - (base + ref->die_offset);
+ /* If there are no references, size stays the same
+ and no need to walk the actual attribute values. */
+ for (i = 0; i < reft->nattr; i++)
+ {
+ t->attr[i].attr = reft->attr[i].attr;
+ t->attr[i].form = reft->attr[i].form;
+ if (t->attr[i].form == DW_FORM_implicit_const)
+ t->values[i] = reft->values[i];
+ }
+ t->nattr = reft->nattr;
+ }
+ else
+ {
+ die->die_size = 0;
+ /* Otherwise, we need to walk the actual attributes. */
+ for (i = 0, j = 0; i < reft->nattr; ++i)
+ {
+ uint32_t form = reft->attr[i].form;
+ size_t len = 0;
+ dw_die_ref refd;
+ uint64_t value = 0;
+ unsigned char *orig_ptr = ptr;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+
+ if (unlikely (wr_multifile || op_multifile)
+ && (reft->attr[i].attr == DW_AT_decl_file
+ || reft->attr[i].attr == DW_AT_call_file))
+ {
+ switch (form)
+ {
+ case DW_FORM_data1: value = read_8 (ptr); break;
+ case DW_FORM_data2: value = read_16 (ptr); break;
+ case DW_FORM_data4: value = read_32 (ptr); break;
+ case DW_FORM_data8: value = read_64 (ptr); break;
+ case DW_FORM_udata: value = read_uleb128 (ptr); break;
+ case DW_FORM_sdata: value = read_sleb128 (ptr); break;
+ case DW_FORM_implicit_const:
+ value = reft->values[i];
+ break;
+ default:
+ error (0, 0, "Unhandled %s for %s",
+ get_DW_FORM_str (form),
+ get_DW_AT_str (reft->attr[i].attr));
+ return 1;
+ }
+ value = line_htab_lookup (refcu, value);
+ if (form != DW_FORM_implicit_const)
+ {
+ if (value <= 0xff)
+ {
+ form = DW_FORM_data1;
+ die->die_size++;
+ }
+ else if (value <= 0xffff)
+ {
+ form = DW_FORM_data2;
+ die->die_size += 2;
+ }
+ else if (value <= 0xffffffff)
+ {
+ form = DW_FORM_data4;
+ die->die_size += 4;
+ }
+ else
+ {
+ form = DW_FORM_data8;
+ die->die_size += 8;
+ }
+ }
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j].form = form;
+ if (form == DW_FORM_implicit_const)
+ t->values[j] = value;
+ j++;
+ continue;
+ }
+
+ if (unlikely (fi_multifile)
+ && (reft->attr[i].attr == DW_AT_GNU_macros
+ || reft->attr[i].attr == DW_AT_macros)
+ && alt_macro_htab != NULL)
+ {
+ struct macro_entry me, *m;
+
+ switch (form)
+ {
+ case DW_FORM_data4:
+ case DW_FORM_sec_offset:
+ value = read_32 (ptr);
+ break;
+ default:
+ error (0, 0, "Unhandled %s for %s",
+ get_DW_FORM_str (form),
+ get_DW_AT_str (reft->attr[i].attr));
+ return 1;
+ }
+ me.ptr = debug_sections[DEBUG_MACRO].data + value;
+ m = (struct macro_entry *)
+ htab_find_with_hash (macro_htab, &me, value);
+ if (m->len)
+ {
+ error (0, 0, "%s referencing transparent include",
+ get_DW_AT_str (reft->attr[i].attr));
+ return 1;
+ }
+ ptr -= 4;
+ }
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ if (unlikely (fi_multifile))
+ {
+ dw_die_ref refdt;
+ value = read_size (ptr,
+ refcu->cu_version == 2
+ ? ptr_size : 4);
+ ptr += refcu->cu_version == 2 ? ptr_size : 4;
+ refd = off_htab_lookup (NULL, value);
+ assert (refd != NULL);
+ refdt = refd;
+ while (refdt->die_toplevel == 0)
+ refdt = refdt->die_parent;
+ if (refdt->die_dup
+ && !refdt->die_op_type_referenced
+ && die_cu (refdt->die_dup)->cu_kind == CU_ALT)
+ {
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j++].form
+ = dwarf_5 ? DW_FORM_ref_sup4 : DW_FORM_GNU_ref_alt;
+ die->die_size += 4;
+ continue;
+ }
+ break;
+ }
+ ptr += refcu->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_addr:
+ ptr += ptr_size;
+ if (reft->attr[i].attr == DW_AT_low_pc
+ && cu->cu_version >= 4)
+ low_pc = read_size (ptr - ptr_size, ptr_size);
+ else if (reft->attr[i].attr == DW_AT_high_pc
+ && low_pc)
+ {
+ uint64_t high_pc = read_size (ptr - ptr_size, ptr_size);
+ /* If both DW_AT_low_pc and DW_AT_high_pc attributes
+ are present and have DW_FORM_addr, attempt to shrink
+ the DIE by using DW_FORM_udata or DW_FORM_data4
+ form for the latter in DWARF4+. Don't try
+ DW_FORM_data[12], that might increase .debug_abbrev
+ size too much or increase the uleb128 size of too
+ many abbrev numbers. */
+ if (high_pc > low_pc)
+ {
+ unsigned int nform = 0;
+ unsigned int sz = size_of_uleb128 (high_pc - low_pc);
+ if (sz <= 4 && sz <= (unsigned) ptr_size)
+ nform = DW_FORM_udata;
+ else if (ptr_size > 4
+ && high_pc - low_pc <= 0xffffffff)
+ {
+ nform = DW_FORM_data4;
+ sz = 4;
+ }
+ else if (sz <= (unsigned) ptr_size)
+ nform = DW_FORM_udata;
+ if (nform)
+ {
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j++].form = nform;
+ die->die_size += sz;
+ continue;
+ }
+ }
+ }
+ break;
+ case DW_FORM_flag_present:
+ case DW_FORM_implicit_const:
+ break;
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ ++ptr;
+ break;
+ case DW_FORM_data2:
+ ptr += 2;
+ break;
+ case DW_FORM_data4:
+ if (reft->attr[i].attr == DW_AT_high_pc)
+ {
+ uint32_t range_len = read_32 (ptr);
+ unsigned int sz = size_of_uleb128 (range_len);
+ if (sz <= 4)
+ {
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j++].form = DW_FORM_udata;
+ die->die_size += sz;
+ continue;
+ }
+ break;
+ }
+ ptr += 4;
+ break;
+ case DW_FORM_sec_offset:
+ ptr += 4;
+ break;
+ case DW_FORM_data8:
+ if (reft->attr[i].attr == DW_AT_high_pc)
+ {
+ unsigned int nform = 0;
+ uint64_t range_len = read_64 (ptr);
+ unsigned int sz = size_of_uleb128 (range_len);
+ if (sz <= 4)
+ nform = DW_FORM_udata;
+ else if (range_len <= 0xffffffff)
+ {
+ nform = DW_FORM_data4;
+ sz = 4;
+ }
+ else if (sz <= 8)
+ nform = DW_FORM_udata;
+ if (nform)
+ {
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j++].form = nform;
+ die->die_size += sz;
+ continue;
+ }
+ break;
+ }
+ ptr += 8;
+ break;
+ case DW_FORM_ref_sig8:
+ ptr += 8;
+ break;
+ case DW_FORM_data16:
+ ptr += 16;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ skip_leb128 (ptr);
+ break;
+ case DW_FORM_strp:
+ if (unlikely (op_multifile || fi_multifile))
+ {
+ form = note_strp_offset2 (read_32 (ptr));
+ if (form != DW_FORM_strp)
+ {
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j++].form = form;
+ die->die_size += 4;
+ continue;
+ }
+ }
+ else
+ ptr += 4;
+ break;
+ case DW_FORM_line_strp:
+ /* Since we don't register the line_strp we cannot
+ change the form in the case of multifile. */
+ ptr += 4;
+ break;
+ case DW_FORM_string:
+ ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1;
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ case DW_FORM_block1:
+ len = *ptr++;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block:
+ case DW_FORM_exprloc:
+ len = read_uleb128 (ptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_ref_udata:
+ switch (form)
+ {
+ case DW_FORM_ref1: value = read_8 (ptr); break;
+ case DW_FORM_ref2: value = read_16 (ptr); break;
+ case DW_FORM_ref4: value = read_32 (ptr); break;
+ case DW_FORM_ref8: value = read_64 (ptr); break;
+ case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+ default: abort ();
+ }
+ if (reft->attr[i].attr == DW_AT_sibling)
+ {
+ if (sib == NULL)
+ continue;
+ form = DW_FORM_ref4;
+ refd = sib;
+ }
+ else
+ {
+ dw_die_ref refdt;
+ refd = off_htab_lookup (refcu, refcu->cu_offset + value);
+ assert (refd != NULL);
+ refdt = refd;
+ while (refdt->die_toplevel == 0)
+ refdt = refdt->die_parent;
+ if (refdt->die_dup && refdt->die_op_type_referenced)
+ {
+ if (cu == die_cu (refdt))
+ form = DW_FORM_ref4;
+ else if (cu == die_cu (refdt->die_dup))
+ {
+ form = DW_FORM_ref4;
+ refd = die_find_dup (refdt, refdt->die_dup,
+ refd);
+ }
+ else
+ form = DW_FORM_ref_addr;
+ }
+ else
+ {
+ if (refdt->die_dup)
+ refd = die_find_dup (refdt, refdt->die_dup, refd);
+ if (cu == die_cu (refd))
+ form = DW_FORM_ref4;
+ else if (die_cu (refd)->cu_kind == CU_ALT)
+ form = (dwarf_5
+ ? DW_FORM_ref_sup4 : DW_FORM_GNU_ref_alt);
+ else
+ form = DW_FORM_ref_addr;
+ }
+ }
+ if (form == DW_FORM_ref_addr)
+ die->die_size += cu->cu_version == 2 ? ptr_size : 4;
+ else if (form == DW_FORM_GNU_ref_alt
+ || form == DW_FORM_ref_sup4)
+ die->die_size += 4;
+ else
+ {
+ if (unlikely (recompute))
+ form = cu->cu_intracu_form;
+ if (likely (!recompute) || form == DW_FORM_ref_udata)
+ {
+ obstack_ptr_grow (vec, die);
+ obstack_ptr_grow (vec, refd);
+ }
+ }
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j++].form = form;
+ continue;
+ default:
+ abort ();
+ }
+
+ if (form == DW_FORM_block1)
+ ptr += len;
+ t->attr[j].attr = reft->attr[i].attr;
+ t->attr[j].form = reft->attr[i].form;
+ if (reft->attr[i].form == DW_FORM_implicit_const)
+ t->values[j] = reft->values[i];
+ j++;
+ die->die_size += ptr - orig_ptr;
+ }
+ t->nattr = j;
+ }
+ }
+ else
+ switch (die->die_tag)
+ {
+ case DW_TAG_partial_unit:
+ case DW_TAG_compile_unit:
+ t->nattr = 0;
+ die->die_size = 0;
+ if (origin == NULL)
+ break;
+ refcu = die_cu (origin);
+ if (refcu->cu_nfiles)
+ {
+ t->attr[0].attr = DW_AT_stmt_list;
+ t->attr[0].form = cu->cu_version < 4
+ ? DW_FORM_data4 : DW_FORM_sec_offset;
+ die->die_size += 4;
+ t->nattr++;
+ }
+ if (uni_lang_p || cu->cu_die->die_tag == DW_TAG_compile_unit)
+ {
+ unsigned int lang_size = nr_bytes_for (cu->lang);
+ die->die_size += lang_size;
+ t->attr[t->nattr].attr = DW_AT_language;
+ switch (lang_size)
+ {
+ case 1:
+ t->attr[t->nattr].form = DW_FORM_data1;
+ break;
+ case 2:
+ t->attr[t->nattr].form = DW_FORM_data2;
+ break;
+ default:
+ abort ();
+ }
+ t->nattr++;
+ }
+ if (refcu->cu_comp_dir)
+ {
+ enum dwarf_form form;
+ unsigned char *ptr = get_AT (origin, DW_AT_comp_dir, &form);
+ assert (ptr && (form == DW_FORM_string
+ || form == DW_FORM_strp
+ || form == DW_FORM_line_strp));
+ if (form == DW_FORM_strp)
+ {
+ if (unlikely (op_multifile || fi_multifile))
+ form = note_strp_offset2 (read_32 (ptr));
+ die->die_size += 4;
+ }
+ else if (form == DW_FORM_line_strp)
+ die->die_size += 4;
+ else
+ die->die_size
+ += strlen (refcu->cu_comp_dir) + 1;
+ t->attr[t->nattr].attr = DW_AT_comp_dir;
+ t->attr[t->nattr].form = form;
+ t->nattr++;
+ }
+ break;
+ case DW_TAG_namespace:
+ case DW_TAG_module:
+ {
+ enum dwarf_form form;
+ unsigned char *ptr = get_AT (origin, DW_AT_name, &form);
+ assert (ptr && (form == DW_FORM_string
+ || form == DW_FORM_strp
+ || form == DW_FORM_line_strp));
+ if (form == DW_FORM_strp)
+ {
+ if (unlikely (op_multifile || fi_multifile))
+ form = note_strp_offset2 (read_32 (ptr));
+ die->die_size = 4;
+ }
+ else if (form == DW_FORM_line_strp)
+ die->die_size += 4;
+ else
+ die->die_size = strlen ((char *) ptr) + 1;
+ t->attr[0].attr = DW_AT_name;
+ t->attr[0].form = form;
+ t->nattr = 1;
+ if (sib)
+ {
+ t->attr[1].attr = DW_AT_sibling;
+ t->attr[1].form = DW_FORM_ref4;
+ obstack_ptr_grow (vec, die);
+ obstack_ptr_grow (vec, sib);
+ t->nattr++;
+ }
+ break;
+ }
+ case DW_TAG_imported_unit:
+ t->attr[0].attr = DW_AT_import;
+ t->nattr = 1;
+ if (die_cu (die->die_nextdup)->cu_kind == CU_ALT)
+ {
+ t->attr[0].form = dwarf_5 ? DW_FORM_ref_sup4 : DW_FORM_GNU_ref_alt;
+ die->die_size = 4;
+ }
+ else
+ {
+ t->attr[0].form = DW_FORM_ref_addr;
+ die->die_size = cu->cu_version == 2 ? ptr_size : 4;
+ }
+ break;
+ default:
+ abort ();
+ }
+ compute_abbrev_hash (t);
+ slot = htab_find_slot_with_hash (h, t, t->hash,
+ recompute ? NO_INSERT : INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (unlikely (recompute))
+ assert (*slot);
+ if (*slot)
+ {
+ if (likely (!recompute))
+ ((struct abbrev_tag *)*slot)->nusers++;
+ die->u.p2.die_new_abbrev = (struct abbrev_tag *)*slot;
+ }
+ else
+ {
+ struct abbrev_tag *newt = pool_clone_abbrev (t);
+ *slot = newt;
+ die->u.p2.die_new_abbrev = newt;
+ }
+ (*ndies)++;
+ if (ref != NULL && ref != die)
+ {
+ for (child = die->die_child, ref_child = ref->die_child;
+ child; child = child->die_sib, ref_child = ref_child->die_sib)
+ if (build_abbrevs_for_die (h, cu, child, refcu, ref_child,
+ t, ndies, vec, recompute))
+ return 1;
+ }
+ else
+ for (child = die->die_child; child; child = child->die_sib)
+ if (build_abbrevs_for_die (h, cu, child, NULL, NULL, t, ndies, vec,
+ recompute))
+ return 1;
+ return 0;
+}
+
+/* Build new abbreviations for CU. T, NDIES and VEC arguments like
+ for build_abbrevs_for_die. */
+static int
+build_abbrevs (dw_cu_ref cu, struct abbrev_tag *t, unsigned int *ndies,
+ struct obstack *vec)
+{
+ htab_t h = htab_try_create (50, abbrev_hash, abbrev_eq2, NULL);
+
+ if (h == NULL)
+ dwz_oom ();
+
+ if (build_abbrevs_for_die (h, cu, cu->cu_die, NULL, NULL, t, ndies, vec,
+ false))
+ {
+ htab_delete (h);
+ return 1;
+ }
+
+ cu->cu_new_abbrev = h;
+ return 0;
+}
+
+/* Helper to record all abbrevs from the hash table into ob obstack
+ vector. Called through htab_traverse. */
+static int
+list_abbrevs (void **slot, void *data)
+{
+ struct obstack *obp = (struct obstack *) data;
+ obstack_ptr_grow (obp, *slot);
+ return 1;
+}
+
+/* Comparison function for abbreviations. Used for CUs that
+ need 128 or more abbreviations. Use lowest numbers (i.e. sort earlier)
+ abbrevs used for typed DWARF stack referenced DIEs, then sort
+ by decreasing number of users (abbrev numbers are uleb128 encoded,
+ the bigger number of them that can be 1 byte encoded the better). */
+static int
+abbrev_cmp (const void *p, const void *q)
+{
+ struct abbrev_tag *t1 = *(struct abbrev_tag **)p;
+ struct abbrev_tag *t2 = *(struct abbrev_tag **)q;
+ unsigned int i;
+
+ if (t1->op_type_referenced && !t2->op_type_referenced)
+ return -1;
+ if (!t1->op_type_referenced && t2->op_type_referenced)
+ return 1;
+ if (t1->nusers > t2->nusers)
+ return -1;
+ if (t1->nusers < t2->nusers)
+ return 1;
+ /* The rest just so that we have a stable sort. */
+ if (t1->tag < t2->tag)
+ return -1;
+ if (t1->tag > t2->tag)
+ return 1;
+ if (t1->nattr < t2->nattr)
+ return -1;
+ if (t1->nattr > t2->nattr)
+ return 1;
+ if (t1->children && !t2->children)
+ return -1;
+ if (!t1->children && t2->children)
+ return 1;
+ for (i = 0; i < t1->nattr; i++)
+ {
+ if (t1->attr[i].attr < t2->attr[i].attr)
+ return -1;
+ if (t1->attr[i].attr > t2->attr[i].attr)
+ return 1;
+ if (t1->attr[i].form < t2->attr[i].form)
+ return -1;
+ if (t1->attr[i].form > t2->attr[i].form)
+ return 1;
+ if (t1->attr[i].form == DW_FORM_implicit_const)
+ {
+ if (t1->values[i] < t2->values[i])
+ return -1;
+ if (t1->values[i] > t2->values[i])
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* First phase of computation of u.p2.die_new_offset and
+ new CU sizes. */
+static unsigned int
+init_new_die_offsets (dw_die_ref die, unsigned int off,
+ unsigned int intracusize)
+{
+ dw_die_ref child;
+ unsigned int i;
+ struct abbrev_tag *t = die->u.p2.die_new_abbrev;
+ if (wr_multifile ? die->die_no_multifile : die->die_remove)
+ return off;
+ die->u.p2.die_new_offset = off;
+ if (likely (die->die_ref_seen == 0))
+ {
+ die->die_size += size_of_uleb128 (die->u.p2.die_new_abbrev->entry);
+ die->u.p2.die_intracu_udata_size = 0;
+ for (i = 0; i < t->nattr; ++i)
+ switch (t->attr[i].form)
+ {
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref_udata:
+ die->u.p2.die_intracu_udata_size += intracusize;
+ break;
+ default:
+ break;
+ }
+ die->die_size += die->u.p2.die_intracu_udata_size;
+ }
+ off += die->die_size;
+ for (child = die->die_child; child; child = child->die_sib)
+ off = init_new_die_offsets (child, off, intracusize);
+ if (die->die_child)
+ off++;
+ return off;
+}
+
+/* Second phase of computation of u.p2.die_new_offset and
+ new CU sizes. This step is called possibly many times,
+ for deciding if DW_FORM_ref_udata is worthwhile.
+ init_new_die_offsets starts with assuming each uleb128 will
+ need maximum number of bytes for the CU of the given size,
+ each new invocation of this function (except the last)
+ will shrink one or more uleb128s. Each shrinking can create
+ new opportunities to shrink other uleb128s. */
+static unsigned int
+update_new_die_offsets (dw_die_ref die, unsigned int off,
+ dw_die_ref **intracuvec)
+{
+ dw_die_ref child;
+ if (wr_multifile ? die->die_no_multifile : die->die_remove)
+ return off;
+ assert (off <= die->u.p2.die_new_offset);
+ die->u.p2.die_new_offset = off;
+ if ((*intracuvec)[0] == die)
+ {
+ unsigned int intracu_udata_size = 0;
+ assert (die->u.p2.die_intracu_udata_size);
+ while ((*intracuvec)[0] == die)
+ {
+ intracu_udata_size
+ += size_of_uleb128 ((*intracuvec)[1]->u.p2.die_new_offset);
+ *intracuvec += 2;
+ }
+ assert (die->u.p2.die_intracu_udata_size >= intracu_udata_size);
+ die->die_size -= die->u.p2.die_intracu_udata_size - intracu_udata_size;
+ die->u.p2.die_intracu_udata_size = intracu_udata_size;
+ }
+ else
+ assert (die->u.p2.die_intracu_udata_size == 0 || die->die_ref_seen);
+ off += die->die_size;
+ for (child = die->die_child; child; child = child->die_sib)
+ off = update_new_die_offsets (child, off, intracuvec);
+ if (die->die_child)
+ off++;
+ return off;
+}
+
+/* Final phase of computation of u.p2.die_new_offset. Called when already
+ decided what intra-CU form will be used. Can return -1U if
+ a problem is detected and the tool should give up. */
+static unsigned int
+finalize_new_die_offsets (dw_cu_ref cu, dw_die_ref die, unsigned int off,
+ unsigned int intracusize, dw_die_ref **intracuvec)
+{
+ dw_die_ref child;
+ unsigned int ref_seen = die->die_ref_seen;
+ if (wr_multifile ? die->die_no_multifile : die->die_remove)
+ return off;
+ die->u.p2.die_new_offset = off;
+ die->die_ref_seen = 0;
+ /* As we aren't adjusting sizes of exprloc, if in the new layout
+ a DIE referenced through DW_OP_call2 is placed after 64K into
+ the CU, punt. */
+ if (die->die_op_call2_referenced && off >= 65536)
+ return -1U;
+ /* Similarly punt if
+ DW_OP_GNU_{{regval,const,deref}_type,convert,reinterpret}
+ references a DIE that needs more uleb128 bytes to encode
+ the new offset compared to uleb128 bytes to encode the old offset.
+ GCC emits DW_TAG_base_type dies referenced that way at the
+ beginning of the CU and we try to preserve that, so this shouldn't
+ trigger for GCC generated code. */
+ if (die->die_op_type_referenced
+ && !wr_multifile
+ && size_of_uleb128 (off)
+ > size_of_uleb128 (die->die_offset - cu->cu_offset))
+ return -1U;
+ if ((*intracuvec)[0] == die)
+ {
+ unsigned int intracu_udata_size = 0;
+ assert (die->u.p2.die_intracu_udata_size);
+ while ((*intracuvec)[0] == die)
+ {
+ intracu_udata_size += intracusize;
+ *intracuvec += 2;
+ }
+ if (intracusize != 0)
+ {
+ die->die_size
+ -= die->u.p2.die_intracu_udata_size - intracu_udata_size;
+ die->u.p2.die_intracu_udata_size = intracu_udata_size;
+ }
+ }
+ else
+ assert (die->u.p2.die_intracu_udata_size == 0 || ref_seen);
+ off += die->die_size;
+ for (child = die->die_child; child; child = child->die_sib)
+ {
+ off = finalize_new_die_offsets (cu, child, off, intracusize, intracuvec);
+ if (off == -1U)
+ return off;
+ }
+ if (die->die_child)
+ off++;
+ return off;
+}
+
+/* Comparison function, called through qsort, to sort CUs
+ by increasing number of needed new abbreviations. */
+static int
+cu_abbrev_cmp (const void *p, const void *q)
+{
+ dw_cu_ref cu1 = *(dw_cu_ref *)p;
+ dw_cu_ref cu2 = *(dw_cu_ref *)q;
+ unsigned int nabbrevs1 = htab_elements (cu1->cu_new_abbrev);
+ unsigned int nabbrevs2 = htab_elements (cu2->cu_new_abbrev);
+
+ if (nabbrevs1 < nabbrevs2)
+ return -1;
+ if (nabbrevs1 > nabbrevs2)
+ return 1;
+ /* The rest is just to get stable sort. */
+ if (cu1->cu_kind != CU_PU && cu2->cu_kind == CU_PU)
+ return -1;
+ if (cu1->cu_kind == CU_PU && cu2->cu_kind != CU_PU)
+ return 1;
+ if (cu1->cu_offset < cu2->cu_offset)
+ return -1;
+ if (cu1->cu_offset > cu2->cu_offset)
+ return 1;
+ return 0;
+}
+
+/* Compute new abbreviations for all CUs, size the new
+ .debug_abbrev section and all new .debug_info CUs. */
+static int
+compute_abbrevs (DSO *dso)
+{
+ unsigned long total_size = 0, types_size = 0, abbrev_size = 0;
+ dw_cu_ref cu, *cuarr;
+ struct abbrev_tag *t;
+ unsigned int ncus, nlargeabbrevs = 0, i, laststart;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "compute_abbrevs\n");
+ }
+
+ t = (struct abbrev_tag *)
+ obstack_alloc (&ob2,
+ sizeof (*t)
+ + (max_nattr + 4) * sizeof (struct abbrev_attr)
+ + (max_nattr + 4) * sizeof (int64_t));
+ t->values = (int64_t *) &t->attr[max_nattr + 4];
+ for (cu = first_cu, ncus = 0; cu; cu = cu->cu_next)
+ {
+ unsigned int intracu, ndies = 0, tagsize = 0, nchildren = 0;
+ unsigned int nabbrevs, diesize, cusize, off, intracusize;
+ struct abbrev_tag **arr;
+ dw_die_ref *intracuarr, *intracuvec;
+ enum dwarf_form intracuform = DW_FORM_ref4;
+ dw_die_ref child, *lastotr, child_next, *last;
+ unsigned int headersz = (cu->cu_kind == CU_TYPES
+ ? 23 : (cu->cu_version >= 5 ? 12 : 11));
+
+ if (unlikely (fi_multifile) && cu->cu_die->die_remove)
+ continue;
+ if (unlikely (low_mem) && cu->cu_kind != CU_PU)
+ expand_children (cu->cu_die);
+ ncus++;
+ if (build_abbrevs (cu, t, &ndies, &ob2))
+ return 1;
+ nabbrevs = htab_elements (cu->cu_new_abbrev);
+ htab_traverse (cu->cu_new_abbrev, list_abbrevs, &ob);
+ assert (obstack_object_size (&ob) == nabbrevs * sizeof (void *));
+ arr = (struct abbrev_tag **) obstack_finish (&ob);
+ intracu = obstack_object_size (&ob2) / sizeof (void *) / 2;
+ obstack_ptr_grow (&ob2, NULL);
+ intracuarr = (dw_die_ref *) obstack_finish (&ob2);
+ if (nabbrevs >= 128)
+ {
+ unsigned int limit, uleb128_size;
+
+ for (child = cu->cu_die->die_child; child; child = child->die_sib)
+ if (child->die_op_type_referenced && !wr_multifile)
+ {
+ child->u.p2.die_new_abbrev->op_type_referenced = 1;
+ /* If the old offset was close to uleb128 boundary, ensure
+ that DW_TAG_compile_unit gets small abbrev number
+ as well. */
+ if (size_of_uleb128 (child->die_offset - cu->cu_offset)
+ < size_of_uleb128 (child->die_offset - cu->cu_offset + 1))
+ cu->cu_die->u.p2.die_new_abbrev->op_type_referenced = 1;
+ }
+ qsort (arr, nabbrevs, sizeof (*arr), abbrev_cmp);
+ for (i = 0, limit = 128, uleb128_size = 1; i < nabbrevs; i++)
+ {
+ if (i + 1 == limit)
+ {
+ limit <<= 7;
+ uleb128_size++;
+ }
+ arr[i]->entry = i + 1;
+ tagsize += arr[i]->nusers * uleb128_size;
+ if (arr[i]->children)
+ nchildren += arr[i]->nusers;
+ }
+ nlargeabbrevs++;
+ }
+ else
+ {
+ tagsize = ndies;
+ for (i = 0; i < nabbrevs; i++)
+ {
+ arr[i]->entry = i + 1;
+ if (arr[i]->children)
+ nchildren += arr[i]->nusers;
+ }
+ }
+
+ /* Move all base types with die_op_type_reference
+ to front, to increase the likelyhood that the offset
+ will fit. */
+ for (last = &cu->cu_die->die_child, lastotr = last, child = *last;
+ child; child = child_next)
+ {
+ child_next = child->die_sib;
+ if (child->die_op_type_referenced)
+ {
+ if (lastotr != last)
+ {
+ child->die_sib = *lastotr;
+ *lastotr = child;
+ lastotr = &child->die_sib;
+ *last = child_next;
+ continue;
+ }
+ lastotr = &child->die_sib;
+ }
+ last = &child->die_sib;
+ }
+
+ cu->u2.cu_largest_entry = nabbrevs;
+ diesize = calc_sizes (cu->cu_die);
+ cusize = headersz + tagsize + diesize + nchildren;
+ intracusize = size_of_uleb128 (cusize + intracu);
+ do
+ {
+ i = size_of_uleb128 (cusize + intracu * intracusize);
+ if (i == intracusize)
+ break;
+ intracusize = i;
+ }
+ while (1);
+ cu->initial_intracusize = intracusize;
+ off = init_new_die_offsets (cu->cu_die, headersz, intracusize);
+ do
+ {
+ intracuvec = intracuarr;
+ i = update_new_die_offsets (cu->cu_die, headersz, &intracuvec);
+ assert (*intracuvec == NULL);
+ if (i == off)
+ break;
+ assert (i < off);
+ off = i;
+ }
+ while (1);
+ if (cusize + intracu <= 256)
+ {
+ intracuform = DW_FORM_ref1;
+ intracusize = 1;
+ cusize += intracu;
+ }
+ else if (cusize + intracu * 2 <= 65536)
+ {
+ intracuform = DW_FORM_ref2;
+ intracusize = 2;
+ cusize += intracu * 2;
+ }
+ else
+ {
+ cusize += intracu * 4;
+ intracusize = 4;
+ }
+ if (off <= cusize)
+ {
+ intracuform = DW_FORM_ref_udata;
+ intracusize = 0;
+ cusize = off;
+ }
+
+ intracuvec = intracuarr;
+ off = finalize_new_die_offsets (cu, cu->cu_die, headersz, intracusize,
+ &intracuvec);
+ if (off == -1U)
+ {
+ error (0, 0, "%s: DW_OP_call2 or typed DWARF stack referenced DIE"
+ " layed out at too big offset", dso->filename);
+ return 1;
+ }
+ assert (*intracuvec == NULL && off == cusize);
+ cu->cu_intracu_form = intracuform;
+
+ if (intracuform != DW_FORM_ref4)
+ {
+ unsigned int j;
+ htab_empty (cu->cu_new_abbrev);
+ for (i = 0; i < nabbrevs; i++)
+ {
+ void **slot;
+ for (j = 0; j < arr[i]->nattr; j++)
+ if (arr[i]->attr[j].form == DW_FORM_ref4)
+ arr[i]->attr[j].form = intracuform;
+ compute_abbrev_hash (arr[i]);
+ slot = htab_find_slot_with_hash (cu->cu_new_abbrev, arr[i],
+ arr[i]->hash, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ assert (slot != NULL && *slot == NULL);
+ *slot = arr[i];
+ }
+ }
+ obstack_free (&ob, (void *) arr);
+ obstack_free (&ob2, (void *) intracuarr);
+ if (cu->cu_kind == CU_TYPES)
+ {
+ cu->cu_new_offset = types_size;
+ types_size += cusize;
+ }
+ else
+ {
+ cu->cu_new_offset = (wr_multifile ? multi_info_off : 0) + total_size;
+ total_size += cusize;
+ }
+
+ if (unlikely (low_mem) && cu->cu_kind != CU_PU)
+ collapse_children (cu, cu->cu_die);
+ }
+ if (wr_multifile)
+ total_size += 11; /* See the end of write_info. */
+ obstack_free (&ob2, (void *) t);
+ cuarr = (dw_cu_ref *) obstack_alloc (&ob2, ncus * sizeof (dw_cu_ref));
+ for (cu = first_cu, i = 0; cu; cu = cu->cu_next)
+ if (cu->u1.cu_new_abbrev_owner == NULL
+ && (likely (!fi_multifile)
+ || cu->cu_kind != CU_NORMAL
+ || !cu->cu_die->die_remove))
+ cuarr[i++] = cu;
+ assert (i == ncus);
+ qsort (cuarr, ncus, sizeof (dw_cu_ref), cu_abbrev_cmp);
+ /* For CUs with < 128 abbrevs, try to see if either all of the
+ abbrevs are at < 128 positions in >= 128 abbrev CUs, or
+ can be merged with some other small abbrev table to form
+ a < 128 abbrev table. */
+ laststart = ncus - nlargeabbrevs;
+ for (i = ncus - 1; i != -1U; i--)
+ {
+ struct abbrev_tag **arr;
+ unsigned int nabbrevs, j, k, nattempts;
+
+ if (cuarr[i]->u1.cu_new_abbrev_owner != NULL)
+ continue;
+ nabbrevs = htab_elements (cuarr[i]->cu_new_abbrev);
+ htab_traverse (cuarr[i]->cu_new_abbrev, list_abbrevs, &ob2);
+ assert (obstack_object_size (&ob2) == nabbrevs * sizeof (void *));
+ arr = (struct abbrev_tag **) obstack_finish (&ob2);
+ if (nabbrevs >= 128)
+ {
+ nattempts = 0;
+ for (j = i + 1; j < ncus; j++)
+ {
+ unsigned int entry;
+ if (cuarr[j]->u1.cu_new_abbrev_owner)
+ continue;
+ if (++nattempts == 100)
+ break;
+ entry = cuarr[j]->u2.cu_largest_entry;
+ for (k = 0; k < nabbrevs; k++)
+ {
+ struct abbrev_tag *t
+ = htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+ arr[k], arr[k]->hash);
+ if (t == NULL)
+ {
+ ++entry;
+ if (size_of_uleb128 (entry)
+ != size_of_uleb128 (arr[k]->entry))
+ break;
+ }
+ else if (size_of_uleb128 (t->entry)
+ != size_of_uleb128 (arr[k]->entry))
+ break;
+ }
+ if (k != nabbrevs)
+ continue;
+ entry = cuarr[j]->u2.cu_largest_entry;
+ for (k = 0; k < nabbrevs; k++)
+ {
+ void **slot
+ = htab_find_slot_with_hash (cuarr[j]->cu_new_abbrev,
+ arr[k], arr[k]->hash,
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot != NULL)
+ arr[k]->entry = ((struct abbrev_tag *) *slot)->entry;
+ else
+ {
+ struct abbrev_tag *newt;
+ arr[k]->entry = ++entry;
+ newt = pool_clone_abbrev (arr[k]);
+ *slot = newt;
+ }
+ }
+ cuarr[j]->u2.cu_largest_entry = entry;
+ cuarr[i]->u1.cu_new_abbrev_owner = cuarr[j];
+ break;
+ }
+ obstack_free (&ob2, (void *) arr);
+ continue;
+ }
+ /* Don't search all CUs, that might be too expensive. So just search
+ 100 of >= 128 abbrev tables, if there are more than 100, different
+ set each time. We are looking for a full match (i.e. that
+ cuarr[i] abbrevs are a subset of cuarr[j] abbrevs, and all of them
+ are in the low positions. */
+ for (j = laststart, nattempts = -1U; nlargeabbrevs; j++)
+ {
+ if (j == ncus)
+ j -= nlargeabbrevs;
+ if (nattempts != -1U && j == laststart)
+ break;
+ if (nattempts == -1U)
+ nattempts = 0;
+ if (cuarr[j]->u1.cu_new_abbrev_owner)
+ continue;
+ if (++nattempts == 100)
+ break;
+ for (k = 0; k < nabbrevs; k++)
+ {
+ struct abbrev_tag *t
+ = htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+ arr[k], arr[k]->hash);
+ if (t == NULL || t->entry >= 128)
+ break;
+ }
+ if (k == nabbrevs)
+ {
+ for (k = 0; k < nabbrevs; k++)
+ {
+ struct abbrev_tag *t
+ = htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+ arr[k], arr[k]->hash);
+ arr[k]->entry = t->entry;
+ }
+ cuarr[i]->u1.cu_new_abbrev_owner = cuarr[j];
+ break;
+ }
+ }
+ if (nlargeabbrevs > 100)
+ laststart = j;
+ if (cuarr[i]->u1.cu_new_abbrev_owner == NULL)
+ {
+ unsigned int maxdups = 0, maxdupidx = 0;
+ /* Next search up to 100 of small abbrev CUs, looking
+ for best match. */
+ nattempts = 0;
+ for (j = i + 1; j < ncus - nlargeabbrevs; j++)
+ {
+ unsigned int curdups = 0;
+ if (cuarr[j]->u1.cu_new_abbrev_owner)
+ continue;
+ if (++nattempts == 100)
+ break;
+ for (k = 0; k < nabbrevs; k++)
+ {
+ struct abbrev_tag *t
+ = htab_find_with_hash (cuarr[j]->cu_new_abbrev,
+ arr[k], arr[k]->hash);
+ if (t != NULL)
+ curdups++;
+ }
+ if (curdups > maxdups
+ && cuarr[j]->u2.cu_largest_entry - curdups + nabbrevs < 128)
+ {
+ maxdups = curdups;
+ maxdupidx = j;
+ if (maxdups == nabbrevs)
+ break;
+ }
+ }
+ if (maxdups)
+ {
+ unsigned int entry = cuarr[maxdupidx]->u2.cu_largest_entry;
+ j = maxdupidx;
+ for (k = 0; k < nabbrevs; k++)
+ {
+ void **slot
+ = htab_find_slot_with_hash (cuarr[j]->cu_new_abbrev,
+ arr[k], arr[k]->hash,
+ INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot != NULL)
+ arr[k]->entry = ((struct abbrev_tag *) *slot)->entry;
+ else
+ {
+ struct abbrev_tag *newt;
+ arr[k]->entry = ++entry;
+ newt = pool_clone_abbrev (arr[k]);
+ *slot = newt;
+ }
+ }
+ cuarr[j]->u2.cu_largest_entry = entry;
+ cuarr[i]->u1.cu_new_abbrev_owner = cuarr[j];
+ }
+ }
+ obstack_free (&ob2, (void *) arr);
+ }
+ obstack_free (&ob2, (void *) t);
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ {
+ struct abbrev_tag **arr;
+ unsigned int nabbrevs, j;
+
+ if (unlikely (fi_multifile)
+ && cu->cu_kind == CU_NORMAL
+ && cu->cu_die->die_remove)
+ continue;
+ if (cu->u1.cu_new_abbrev_owner != NULL)
+ {
+ cu->u2.cu_new_abbrev_offset = -1U;
+ if (cu->cu_new_abbrev)
+ htab_delete (cu->cu_new_abbrev);
+ cu->cu_new_abbrev = NULL;
+ continue;
+ }
+ cu->u2.cu_new_abbrev_offset
+ = (wr_multifile ? multi_abbrev_off : 0) + abbrev_size;
+ nabbrevs = htab_elements (cu->cu_new_abbrev);
+ htab_traverse (cu->cu_new_abbrev, list_abbrevs, &ob);
+ assert (obstack_object_size (&ob) == nabbrevs * sizeof (void *));
+ arr = (struct abbrev_tag **) obstack_finish (&ob);
+ for (i = 0; i < nabbrevs; i++)
+ {
+ abbrev_size += size_of_uleb128 (arr[i]->entry);
+ abbrev_size += size_of_uleb128 (arr[i]->tag);
+ abbrev_size += 1;
+ for (j = 0; j < arr[i]->nattr; j++)
+ {
+ abbrev_size += size_of_uleb128 (arr[i]->attr[j].attr);
+ abbrev_size += size_of_uleb128 (arr[i]->attr[j].form);
+ if (arr[i]->attr[j].form == DW_FORM_implicit_const)
+ abbrev_size += size_of_sleb128 (arr[i]->values[j]);
+ }
+ abbrev_size += 2;
+ }
+ abbrev_size += 1;
+ obstack_free (&ob, (void *) arr);
+ }
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ if (unlikely (fi_multifile)
+ && cu->cu_kind == CU_NORMAL
+ && cu->cu_die->die_remove)
+ continue;
+ else if (cu->u2.cu_new_abbrev_offset == -1U)
+ {
+ dw_cu_ref owner = cu;
+ unsigned int cu_new_abbrev_offset;
+ while (owner->u1.cu_new_abbrev_owner != NULL)
+ owner = owner->u1.cu_new_abbrev_owner;
+ cu_new_abbrev_offset = owner->u2.cu_new_abbrev_offset;
+ owner = cu;
+ while (owner->u1.cu_new_abbrev_owner != NULL)
+ {
+ owner->u2.cu_new_abbrev_offset = cu_new_abbrev_offset;
+ owner = owner->u1.cu_new_abbrev_owner;
+ }
+ }
+ debug_sections[DEBUG_INFO].new_size = total_size;
+ debug_sections[DEBUG_ABBREV].new_size = abbrev_size;
+ debug_sections[DEBUG_TYPES].new_size = types_size;
+ return 0;
+}
+
+/* Comparison function, sort abbreviations by increasing
+ entry value. */
+static int
+abbrev_entry_cmp (const void *p, const void *q)
+{
+ struct abbrev_tag *t1 = *(struct abbrev_tag **)p;
+ struct abbrev_tag *t2 = *(struct abbrev_tag **)q;
+
+ if (t1->entry < t2->entry)
+ return -1;
+ if (t1->entry > t2->entry)
+ return 1;
+ return 0;
+}
+
+/* Construct the new .debug_abbrev section
+ in malloced memory, store it as debug_sections[DEBUG_ABBREV].new_data. */
+static void
+write_abbrev (void)
+{
+ dw_cu_ref cu;
+ unsigned char *abbrev = malloc (debug_sections[DEBUG_ABBREV].new_size);
+ unsigned char *ptr = abbrev;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_abbrev\n");
+ }
+
+ if (abbrev == NULL)
+ dwz_oom ();
+
+ debug_sections[DEBUG_ABBREV].new_data = abbrev;
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ {
+ struct abbrev_tag **arr;
+ unsigned int nabbrevs, i, j;
+
+ if (unlikely (fi_multifile)
+ && cu->cu_kind == CU_NORMAL
+ && cu->cu_die->die_remove)
+ continue;
+ if (cu->u1.cu_new_abbrev_owner != NULL)
+ continue;
+ nabbrevs = htab_elements (cu->cu_new_abbrev);
+ htab_traverse (cu->cu_new_abbrev, list_abbrevs, &ob);
+ assert (obstack_object_size (&ob) == nabbrevs * sizeof (void *));
+ arr = (struct abbrev_tag **) obstack_finish (&ob);
+ qsort (arr, nabbrevs, sizeof (*arr), abbrev_entry_cmp);
+ for (i = 0; i < nabbrevs; i++)
+ {
+ write_uleb128 (ptr, arr[i]->entry);
+ write_uleb128 (ptr, arr[i]->tag);
+ *ptr++ = arr[i]->children ? DW_CHILDREN_yes : DW_CHILDREN_no;
+ for (j = 0; j < arr[i]->nattr; j++)
+ {
+ write_uleb128 (ptr, arr[i]->attr[j].attr);
+ write_uleb128 (ptr, arr[i]->attr[j].form);
+ if (arr[i]->attr[j].form == DW_FORM_implicit_const)
+ write_sleb128 (ptr, arr[i]->values[j]);
+ }
+ *ptr++ = 0;
+ *ptr++ = 0;
+ }
+ *ptr++ = 0;
+ obstack_free (&ob, (void *) arr);
+ if (likely (!low_mem))
+ {
+ htab_delete (cu->cu_new_abbrev);
+ cu->cu_new_abbrev = NULL;
+ }
+ }
+ assert (abbrev + debug_sections[DEBUG_ABBREV].new_size == ptr);
+}
+
+/* Adjust DWARF expression starting at PTR, LEN bytes long, referenced by
+ DIE, with REF being the original DIE. */
+static void
+adjust_exprloc (dw_cu_ref cu, dw_die_ref die, dw_cu_ref refcu,
+ dw_die_ref ref, unsigned char *ptr, size_t len)
+{
+ unsigned char *end = ptr + len, *orig_ptr = NULL;
+ unsigned char op;
+ uint32_t leni;
+ GElf_Addr addr;
+ dw_die_ref refd, refdt;
+
+ while (ptr < end)
+ {
+ op = *ptr++;
+ switch (op)
+ {
+ case DW_OP_addr:
+ ptr += ptr_size;
+ break;
+ case DW_OP_deref:
+ case DW_OP_dup:
+ case DW_OP_drop:
+ case DW_OP_over:
+ case DW_OP_swap:
+ case DW_OP_rot:
+ case DW_OP_xderef:
+ case DW_OP_abs:
+ case DW_OP_and:
+ case DW_OP_div:
+ case DW_OP_minus:
+ case DW_OP_mod:
+ case DW_OP_mul:
+ case DW_OP_neg:
+ case DW_OP_not:
+ case DW_OP_or:
+ case DW_OP_plus:
+ case DW_OP_shl:
+ case DW_OP_shr:
+ case DW_OP_shra:
+ case DW_OP_xor:
+ case DW_OP_eq:
+ case DW_OP_ge:
+ case DW_OP_gt:
+ case DW_OP_le:
+ case DW_OP_lt:
+ case DW_OP_ne:
+ case DW_OP_lit0 ... DW_OP_lit31:
+ case DW_OP_reg0 ... DW_OP_reg31:
+ case DW_OP_nop:
+ case DW_OP_push_object_address:
+ case DW_OP_form_tls_address:
+ case DW_OP_call_frame_cfa:
+ case DW_OP_stack_value:
+ case DW_OP_GNU_push_tls_address:
+ case DW_OP_GNU_uninit:
+ break;
+ case DW_OP_const1u:
+ case DW_OP_pick:
+ case DW_OP_deref_size:
+ case DW_OP_xderef_size:
+ case DW_OP_const1s:
+ ++ptr;
+ break;
+ case DW_OP_const2u:
+ case DW_OP_const2s:
+ case DW_OP_skip:
+ case DW_OP_bra:
+ ptr += 2;
+ break;
+ case DW_OP_call2:
+ case DW_OP_call4:
+ case DW_OP_GNU_parameter_ref:
+ if (op == DW_OP_call2)
+ addr = read_16 (ptr);
+ else
+ addr = read_32 (ptr);
+ refd = off_htab_lookup (refcu, refcu->cu_offset + addr);
+ assert (refd != NULL && !refd->die_remove);
+ if (op == DW_OP_call2)
+ {
+ assert (refd->u.p2.die_new_offset <= 65535);
+ ptr -= 2;
+ write_16 (ptr, refd->u.p2.die_new_offset);
+ }
+ else
+ {
+ ptr -= 4;
+ write_32 (ptr, refd->u.p2.die_new_offset);
+ }
+ break;
+ case DW_OP_const4u:
+ case DW_OP_const4s:
+ ptr += 4;
+ break;
+ case DW_OP_call_ref:
+ case DW_OP_GNU_implicit_pointer:
+ case DW_OP_implicit_pointer:
+ case DW_OP_GNU_variable_value:
+ addr = read_size (ptr, refcu->cu_version == 2 ? ptr_size : 4);
+ assert (cu->cu_version == refcu->cu_version);
+ refd = off_htab_lookup (NULL, addr);
+ assert (refd != NULL);
+ refdt = refd;
+ while (refdt->die_toplevel == 0)
+ refdt = refdt->die_parent;
+ if (refdt->die_dup && !refdt->die_op_type_referenced)
+ refd = die_find_dup (refdt, refdt->die_dup, refd);
+ write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+ die_cu (refd)->cu_new_offset
+ + refd->u.p2.die_new_offset);
+ if (cu->cu_version == 2)
+ ptr += ptr_size;
+ else
+ ptr += 4;
+ if (op == DW_OP_GNU_implicit_pointer || op == DW_OP_implicit_pointer)
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_const8u:
+ case DW_OP_const8s:
+ ptr += 8;
+ break;
+ case DW_OP_constu:
+ case DW_OP_plus_uconst:
+ case DW_OP_regx:
+ case DW_OP_piece:
+ case DW_OP_consts:
+ case DW_OP_breg0 ... DW_OP_breg31:
+ case DW_OP_fbreg:
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_bregx:
+ case DW_OP_bit_piece:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ break;
+ case DW_OP_implicit_value:
+ leni = read_uleb128 (ptr);
+ ptr += leni;
+ break;
+ case DW_OP_GNU_entry_value:
+ case DW_OP_entry_value:
+ leni = read_uleb128 (ptr);
+ assert ((uint64_t) (end - ptr) >= leni);
+ adjust_exprloc (cu, die, refcu, ref, ptr, leni);
+ ptr += leni;
+ break;
+ case DW_OP_GNU_convert:
+ case DW_OP_convert:
+ case DW_OP_GNU_reinterpret:
+ case DW_OP_reinterpret:
+ orig_ptr = ptr;
+ addr = read_uleb128 (ptr);
+ if (addr == 0)
+ break;
+ goto typed_dwarf;
+ case DW_OP_GNU_regval_type:
+ case DW_OP_regval_type:
+ skip_leb128 (ptr);
+ orig_ptr = ptr;
+ addr = read_uleb128 (ptr);
+ goto typed_dwarf;
+ case DW_OP_GNU_const_type:
+ case DW_OP_const_type:
+ orig_ptr = ptr;
+ addr = read_uleb128 (ptr);
+ goto typed_dwarf;
+ case DW_OP_GNU_deref_type:
+ case DW_OP_deref_type:
+ ++ptr;
+ orig_ptr = ptr;
+ addr = read_uleb128 (ptr);
+ typed_dwarf:
+ refd = off_htab_lookup (refcu, refcu->cu_offset + addr);
+ assert (refd != NULL && refd->die_op_type_referenced);
+ leni = ptr - orig_ptr;
+ assert (size_of_uleb128 (refd->u.p2.die_new_offset) <= leni);
+ ptr = orig_ptr;
+ write_uleb128 (ptr, refd->u.p2.die_new_offset);
+ /* If the new offset ends up being shorter uleb128
+ encoded than the old, pad it up to make it still valid,
+ but not shortest, uleb128. Changing sizes of
+ exprloc would be a nightmare. Another alternative would
+ be to pad with DW_OP_nop after the op. */
+ if (ptr < orig_ptr + leni)
+ {
+ ptr[-1] |= 0x80;
+ while (ptr < orig_ptr + leni - 1)
+ *ptr++ = 0x80;
+ *ptr++ = 0;
+ }
+ if (op == DW_OP_GNU_const_type || op == DW_OP_const_type)
+ ptr += *ptr + 1;
+ break;
+ default:
+ abort ();
+ }
+ }
+}
+
+/* Write DW_TAG_unit_* DIE (with ORIGIN being the corresponding original DIE) to
+ memory starting at PTR, return pointer after the DIE. */
+static unsigned char *
+write_unit_die (unsigned char *ptr, dw_die_ref die, dw_die_ref origin)
+{
+ struct abbrev_tag *t = die->u.p2.die_new_abbrev;
+ unsigned int i;
+
+ for (i = 0; i < t->nattr; ++i)
+ {
+ struct abbrev_attr *attr = &t->attr[i];
+ switch (attr->attr)
+ {
+ case DW_AT_stmt_list:
+ {
+ enum dwarf_form form;
+ unsigned char *p = get_AT (origin, DW_AT_stmt_list, &form);
+ assert (p && (form == DW_FORM_sec_offset
+ || form == DW_FORM_data4));
+ if (wr_multifile)
+ write_32 (ptr, multi_line_off);
+ else if (op_multifile)
+ write_32 (ptr, 0);
+ else
+ {
+ memcpy (ptr, p, 4);
+ ptr += 4;
+ }
+ }
+ break;
+ case DW_AT_comp_dir:
+ {
+ enum dwarf_form form;
+ unsigned char *p = get_AT (origin, DW_AT_comp_dir, &form);
+ assert (p);
+ assert (form == attr->form
+ || (form == DW_FORM_strp
+ && (attr->form == DW_FORM_GNU_strp_alt
+ || attr->form == DW_FORM_strp_sup)));
+ if (form == DW_FORM_strp)
+ {
+ if (unlikely (wr_multifile || op_multifile || fi_multifile))
+ {
+ unsigned int strp = lookup_strp_offset (read_32 (p));
+ write_32 (ptr, strp);
+ }
+ else
+ {
+ memcpy (ptr, p, 4);
+ ptr += 4;
+ }
+ }
+ else if (form == DW_FORM_line_strp)
+ {
+ memcpy (ptr, p, 4);
+ ptr += 4;
+ }
+ else
+ {
+ size_t len = strlen ((char *) p) + 1;
+ memcpy (ptr, p, len);
+ ptr += len;
+ }
+ }
+ break;
+ case DW_AT_language:
+ {
+ enum dwarf_source_language lang = die_cu (die)->lang;
+ unsigned int lang_size = nr_bytes_for (lang);
+ write_size (ptr, lang_size, lang);
+ ptr += lang_size;
+ }
+ break;
+ default:
+ assert (false);
+ break;
+ }
+ }
+
+ return ptr;
+}
+
+/* Write DIE (with REF being the corresponding original DIE) to
+ memory starting at PTR, return pointer after the DIE. */
+static unsigned char *
+write_die (unsigned char *ptr, dw_cu_ref cu, dw_die_ref die,
+ dw_cu_ref refcu, dw_die_ref ref, unsigned int *die_count)
+{
+ uint64_t low_pc = 0;
+ dw_die_ref child, sib = NULL, origin = NULL;
+ struct abbrev_tag *t;
+
+ if (wr_multifile ? die->die_no_multifile : die->die_remove)
+ return ptr;
+ if (die_count)
+ (*die_count)++;
+ if (die->die_offset == -1U)
+ {
+ if (ref != NULL)
+ ;
+ else if (die_safe_nextdup (die) && die->die_nextdup->die_dup == die)
+ {
+ ref = die->die_nextdup;
+ refcu = die_cu (ref);
+ }
+ if (ref == NULL)
+ origin = die->die_nextdup;
+ }
+ else
+ {
+ ref = die;
+ refcu = cu;
+ if (wr_multifile
+ && (die->die_root || die->die_named_namespace))
+ origin = die;
+ }
+ if (die->die_child && die->die_sib)
+ for (sib = die->die_sib; sib; sib = sib->die_sib)
+ if (wr_multifile ? !sib->die_no_multifile : !sib->die_remove)
+ break;
+ t = die->u.p2.die_new_abbrev;
+ write_uleb128 (ptr, t->entry);
+ if (ref != NULL && origin == NULL)
+ {
+ unsigned char *base
+ = cu->cu_kind == CU_TYPES
+ ? debug_sections[DEBUG_TYPES].data
+ : debug_sections[DEBUG_INFO].data;
+ unsigned char *inptr = base + ref->die_offset;
+ struct abbrev_tag *reft = ref->die_abbrev;
+ unsigned int i, j;
+
+ skip_leb128 (inptr);
+ for (i = 0, j = 0; i < reft->nattr; ++i)
+ {
+ uint32_t form = reft->attr[i].form;
+ size_t len = 0;
+ uint64_t value;
+ unsigned char *orig_ptr = inptr;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (inptr);
+
+ if (unlikely (wr_multifile || op_multifile)
+ && (reft->attr[i].attr == DW_AT_decl_file
+ || reft->attr[i].attr == DW_AT_call_file))
+ {
+ switch (form)
+ {
+ case DW_FORM_data1:
+ value = read_8 (inptr);
+ break;
+ case DW_FORM_data2:
+ value = read_16 (inptr);
+ break;
+ case DW_FORM_data4:
+ value = read_32 (inptr);
+ break;
+ case DW_FORM_data8:
+ value = read_64 (inptr);
+ break;
+ case DW_FORM_udata:
+ value = read_uleb128 (inptr);
+ break;
+ case DW_FORM_sdata:
+ value = read_sleb128 (inptr);
+ break;
+ case DW_FORM_implicit_const:
+ /* DW_FORM_implicit_const should have been updated
+ already when computing abbrevs. */
+ j++;
+ continue;
+ default: abort ();
+ }
+ value = line_htab_lookup (refcu, value);
+ switch (t->attr[j].form)
+ {
+ case DW_FORM_data1: write_8 (ptr, value); break;
+ case DW_FORM_data2: write_16 (ptr, value); break;
+ case DW_FORM_data4: write_32 (ptr, value); break;
+ case DW_FORM_data8: write_64 (ptr, value); break;
+ case DW_FORM_udata: write_uleb128 (ptr, value); break;
+ case DW_FORM_sdata: write_sleb128 (ptr, value); break;
+ default: abort ();
+ }
+ j++;
+ continue;
+ }
+
+ if (unlikely (fi_multifile)
+ && (reft->attr[i].attr == DW_AT_GNU_macros
+ || reft->attr[i].attr == DW_AT_macros)
+ && alt_macro_htab != NULL)
+ {
+ struct macro_entry me, *m;
+
+ memcpy (ptr, orig_ptr, inptr - orig_ptr);
+ ptr += inptr - orig_ptr;
+ value = read_32 (inptr);
+ me.ptr = debug_sections[DEBUG_MACRO].data + value;
+ m = (struct macro_entry *)
+ htab_find_with_hash (macro_htab, &me, value);
+ write_32 (ptr, m->hash);
+ j++;
+ continue;
+ }
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ {
+ dw_die_ref refd, refdt;
+ if (t->attr[j].form != DW_FORM_GNU_ref_alt
+ && t->attr[j].form != DW_FORM_ref_sup4)
+ {
+ memcpy (ptr, orig_ptr, inptr - orig_ptr);
+ ptr += inptr - orig_ptr;
+ }
+ value = read_size (inptr, refcu->cu_version == 2
+ ? ptr_size : 4);
+ inptr += refcu->cu_version == 2 ? ptr_size : 4;
+ refd = off_htab_lookup (NULL, value);
+ if (refd == NULL || refd->die_tag == 0)
+ error (1, 0, "Couldn't find DIE at DW_FORM_ref_addr offset"
+ " 0x%" PRIx64, value);
+ assert (refd != NULL);
+ refdt = refd;
+ while (refdt->die_toplevel == 0)
+ refdt = refdt->die_parent;
+ if (refdt->die_dup && !refdt->die_op_type_referenced)
+ {
+ refd = die_find_dup (refdt, refdt->die_dup, refd);
+ if (t->attr[j].form == DW_FORM_GNU_ref_alt
+ || t->attr[j].form == DW_FORM_ref_sup4)
+ {
+ assert (die_cu (refd)->cu_kind == CU_ALT);
+ write_32 (ptr, refd->die_offset);
+ j++;
+ continue;
+ }
+ }
+ assert (refd->u.p2.die_new_offset
+ && t->attr[j].form != DW_FORM_GNU_ref_alt
+ && t->attr[j].form != DW_FORM_ref_sup4);
+ value = die_cu (refd)->cu_new_offset
+ + refd->u.p2.die_new_offset;
+ write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+ value);
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ if (unlikely (op_multifile))
+ assert (die_cu (refd)->cu_kind == CU_PU);
+ j++;
+ continue;
+ }
+ case DW_FORM_addr:
+ inptr += ptr_size;
+ if (reft->attr[i].attr == DW_AT_low_pc)
+ low_pc = read_size (inptr - ptr_size, ptr_size);
+ if (reft->attr[i].attr == DW_AT_high_pc
+ && t->attr[j].form != reft->attr[i].form)
+ {
+ uint64_t high_pc = read_size (inptr - ptr_size, ptr_size);
+ switch (t->attr[j].form)
+ {
+ case DW_FORM_udata:
+ write_uleb128 (ptr, high_pc - low_pc);
+ break;
+ case DW_FORM_data4:
+ write_32 (ptr, high_pc - low_pc);
+ break;
+ default:
+ abort ();
+ }
+ j++;
+ continue;
+ }
+ break;
+ case DW_FORM_flag_present:
+ case DW_FORM_implicit_const:
+ break;
+ case DW_FORM_flag:
+ case DW_FORM_data1:
+ ++inptr;
+ break;
+ case DW_FORM_data2:
+ inptr += 2;
+ break;
+ case DW_FORM_data4:
+ if (reft->attr[i].attr == DW_AT_high_pc
+ && t->attr[j].form != reft->attr[i].form)
+ {
+ uint32_t range_len = read_32 (inptr);
+ switch (t->attr[j].form)
+ {
+ case DW_FORM_udata:
+ write_uleb128 (ptr, range_len);
+ break;
+ default:
+ abort ();
+ }
+ j++;
+ continue;
+ }
+ inptr += 4;
+ break;
+ case DW_FORM_sec_offset:
+ inptr += 4;
+ break;
+ case DW_FORM_data8:
+ if (reft->attr[i].attr == DW_AT_high_pc
+ && t->attr[j].form != reft->attr[i].form)
+ {
+ uint64_t range_len = read_64 (inptr);
+ switch (t->attr[j].form)
+ {
+ case DW_FORM_udata:
+ write_uleb128 (ptr, range_len);
+ break;
+ case DW_FORM_data4:
+ write_32 (ptr, range_len);
+ break;
+ default:
+ abort ();
+ }
+ j++;
+ continue;
+ }
+ inptr += 8;
+ break;
+ case DW_FORM_ref_sig8:
+ inptr += 8;
+ break;
+ case DW_FORM_data16:
+ inptr += 16;
+ break;
+ case DW_FORM_sdata:
+ case DW_FORM_udata:
+ skip_leb128 (inptr);
+ break;
+ case DW_FORM_strp:
+ if (unlikely (wr_multifile || op_multifile || fi_multifile))
+ {
+ unsigned int strp = lookup_strp_offset (read_32 (inptr));
+ memcpy (ptr, orig_ptr, inptr - 4 - orig_ptr);
+ ptr += inptr - 4 - orig_ptr;
+ write_32 (ptr, strp);
+ j++;
+ continue;
+ }
+ inptr += 4;
+ break;
+ case DW_FORM_line_strp:
+ inptr += 4;
+ break;
+ case DW_FORM_string:
+ inptr = (unsigned char *) strchr ((char *)inptr, '\0') + 1;
+ break;
+ case DW_FORM_indirect:
+ abort ();
+ case DW_FORM_block1:
+ len = *inptr++;
+ break;
+ case DW_FORM_block2:
+ len = read_16 (inptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block4:
+ len = read_32 (inptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_block:
+ len = read_uleb128 (inptr);
+ form = DW_FORM_block1;
+ break;
+ case DW_FORM_exprloc:
+ len = read_uleb128 (inptr);
+ break;
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ case DW_FORM_ref_udata:
+ switch (form)
+ {
+ case DW_FORM_ref1: value = read_8 (inptr); break;
+ case DW_FORM_ref2: value = read_16 (inptr); break;
+ case DW_FORM_ref4: value = read_32 (inptr); break;
+ case DW_FORM_ref8: value = read_64 (inptr); break;
+ case DW_FORM_ref_udata: value = read_uleb128 (inptr); break;
+ default: abort ();
+ }
+ if (reft->attr[i].attr == DW_AT_sibling)
+ {
+ if (j == t->nattr
+ || t->attr[j].attr != DW_AT_sibling)
+ continue;
+ assert (sib);
+ value = sib->u.p2.die_new_offset;
+ }
+ else
+ {
+ dw_die_ref refdt, refd
+ = off_htab_lookup (refcu, refcu->cu_offset + value);
+ assert (refd != NULL);
+ refdt = refd;
+ while (refdt->die_toplevel == 0)
+ refdt = refdt->die_parent;
+ if (refdt->die_dup && refdt->die_op_type_referenced
+ && cu->cu_kind != CU_PU)
+ {
+ if (cu == die_cu (refdt->die_dup))
+ refd = die_find_dup (refdt, refdt->die_dup, refd);
+ }
+ else if (refdt->die_dup)
+ refd = die_find_dup (refdt, refdt->die_dup, refd);
+ if (t->attr[j].form == DW_FORM_GNU_ref_alt
+ || t->attr[j].form == DW_FORM_ref_sup4)
+ {
+ value = refd->die_offset;
+ assert (die_cu (refd)->cu_kind == CU_ALT);
+ }
+ else
+ {
+ dw_cu_ref refdcu = die_cu (refd);
+ value = refd->u.p2.die_new_offset;
+ assert (IMPLIES (cu->cu_kind == CU_PU,
+ die_cu (refd)->cu_kind == CU_PU));
+ assert (value && refdcu->cu_kind != CU_ALT);
+ if (t->attr[j].form == DW_FORM_ref_addr)
+ {
+ value += refdcu->cu_new_offset;
+ if (unlikely (op_multifile))
+ assert (refdcu->cu_kind == CU_PU);
+ }
+ else
+ assert (refdcu == cu);
+ }
+ }
+ switch (t->attr[j].form)
+ {
+ case DW_FORM_ref1: write_8 (ptr, value); break;
+ case DW_FORM_ref2: write_16 (ptr, value); break;
+ case DW_FORM_ref4: write_32 (ptr, value); break;
+ case DW_FORM_ref_udata: write_uleb128 (ptr, value); break;
+ case DW_FORM_ref_addr:
+ write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+ value);
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ break;
+ case DW_FORM_GNU_ref_alt:
+ case DW_FORM_ref_sup4:
+ write_32 (ptr, value);
+ break;
+ case DW_FORM_ref_sup8:
+ write_64 (ptr, value);
+ break;
+ default:
+ abort ();
+ }
+ j++;
+ continue;
+ default:
+ abort ();
+ }
+
+ if (form == DW_FORM_block1 || form == DW_FORM_exprloc)
+ inptr += len;
+
+ memcpy (ptr, orig_ptr, inptr - orig_ptr);
+ ptr += inptr - orig_ptr;
+
+ /* Old DWARF uses blocks instead of exprlocs. */
+ if (form == DW_FORM_block1 && cu->cu_version < 4)
+ switch (reft->attr[i].attr)
+ {
+ case DW_AT_frame_base:
+ case DW_AT_location:
+ case DW_AT_data_member_location:
+ case DW_AT_vtable_elem_location:
+ case DW_AT_byte_size:
+ case DW_AT_bit_offset:
+ case DW_AT_bit_size:
+ case DW_AT_string_length:
+ case DW_AT_lower_bound:
+ case DW_AT_return_addr:
+ case DW_AT_bit_stride:
+ case DW_AT_upper_bound:
+ case DW_AT_count:
+ case DW_AT_segment:
+ case DW_AT_static_link:
+ case DW_AT_use_location:
+ case DW_AT_allocated:
+ case DW_AT_associated:
+ case DW_AT_data_location:
+ case DW_AT_byte_stride:
+ case DW_AT_rank:
+ case DW_AT_call_value:
+ case DW_AT_call_target:
+ case DW_AT_call_target_clobbered:
+ case DW_AT_call_data_location:
+ case DW_AT_call_data_value:
+ case DW_AT_GNU_call_site_value:
+ case DW_AT_GNU_call_site_data_value:
+ case DW_AT_GNU_call_site_target:
+ case DW_AT_GNU_call_site_target_clobbered:
+ adjust_exprloc (cu, die, refcu, ref, ptr - len, len);
+ default:
+ break;
+ }
+ else if (form == DW_FORM_exprloc)
+ adjust_exprloc (cu, die, refcu, ref, ptr - len, len);
+ j++;
+ }
+ assert (j == t->nattr);
+ }
+ else
+ switch (die->die_tag)
+ {
+ case DW_TAG_partial_unit:
+ case DW_TAG_compile_unit:
+ ptr = write_unit_die (ptr, die, origin);
+ break;
+ case DW_TAG_namespace:
+ case DW_TAG_module:
+ {
+ enum dwarf_form form;
+ unsigned char *p = get_AT (origin, DW_AT_name, &form);
+ assert (p && (form == t->attr[0].form
+ || (form == DW_FORM_strp
+ && (t->attr[0].form == DW_FORM_GNU_strp_alt
+ || t->attr[0].form == DW_FORM_strp_sup))));
+ if (form == DW_FORM_strp)
+ {
+ if (unlikely (wr_multifile || op_multifile || fi_multifile))
+ {
+ unsigned int strp = lookup_strp_offset (read_32 (p));
+ write_32 (ptr, strp);
+ }
+ else
+ {
+ memcpy (ptr, p, 4);
+ ptr += 4;
+ }
+ }
+ else if (form == DW_FORM_line_strp)
+ {
+ memcpy (ptr, p, 4);
+ ptr += 4;
+ }
+ else
+ {
+ size_t len = strlen ((char *) p) + 1;
+ memcpy (ptr, p, len);
+ ptr += len;
+ }
+ if (t->nattr > 1)
+ {
+ assert (sib);
+ switch (t->attr[1].form)
+ {
+ case DW_FORM_ref1:
+ write_8 (ptr, sib->u.p2.die_new_offset);
+ break;
+ case DW_FORM_ref2:
+ write_16 (ptr, sib->u.p2.die_new_offset);
+ break;
+ case DW_FORM_ref4:
+ write_32 (ptr, sib->u.p2.die_new_offset);
+ break;
+ case DW_FORM_ref_udata:
+ write_uleb128 (ptr, sib->u.p2.die_new_offset);
+ break;
+ default:
+ abort ();
+ }
+ }
+ break;
+ }
+ case DW_TAG_imported_unit:
+ refcu = die_cu (origin);
+ if (t->attr[0].form == DW_FORM_GNU_ref_alt
+ || t->attr[0].form == DW_FORM_ref_sup4)
+ {
+ assert (refcu->cu_kind == CU_ALT);
+ write_32 (ptr, origin->die_offset);
+ break;
+ }
+ assert (refcu->cu_kind != CU_ALT);
+ write_size (ptr, cu->cu_version == 2 ? ptr_size : 4,
+ refcu->cu_new_offset
+ + origin->u.p2.die_new_offset);
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ break;
+ default:
+ abort ();
+ }
+ if (ref != NULL && ref != die)
+ {
+ dw_die_ref ref_child;
+ for (child = die->die_child, ref_child = ref->die_child;
+ child; child = child->die_sib, ref_child = ref_child->die_sib)
+ ptr = write_die (ptr, cu, child, refcu, ref_child, die_count);
+ }
+ else
+ for (child = die->die_child; child; child = child->die_sib)
+ ptr = write_die (ptr, cu, child, NULL, NULL, die_count);
+ if (die->die_child)
+ write_8 (ptr, 0);
+ return ptr;
+}
+
+/* Recompute abbrevs for CU. If any children were collapsed during
+ compute_abbrevs, their ->u.p2.die_new_abbrev and ->u.p2.die_new_offset
+ fields are no longer available and need to be computed again. */
+static void
+recompute_abbrevs (dw_cu_ref cu, unsigned int cu_size)
+{
+ unsigned int headersz = (cu->cu_kind == CU_TYPES
+ ? 23 : (cu->cu_version >= 5 ? 12 : 11));
+ struct abbrev_tag *t;
+ unsigned int ndies = 0, intracusize, off, i;
+ dw_die_ref *intracuarr, *intracuvec;
+
+ t = (struct abbrev_tag *)
+ obstack_alloc (&ob2,
+ sizeof (*t)
+ + (max_nattr + 4) * sizeof (struct abbrev_attr)
+ + (max_nattr + 4) * sizeof (int64_t));
+ t->values = (int64_t *) &t->attr[max_nattr + 4];
+
+ build_abbrevs_for_die (cu->u1.cu_new_abbrev_owner
+ ? cu->u1.cu_new_abbrev_owner->cu_new_abbrev
+ : cu->cu_new_abbrev, cu, cu->cu_die, NULL, NULL, t,
+ &ndies, &ob2, true);
+
+ obstack_ptr_grow (&ob2, NULL);
+ intracuarr = (dw_die_ref *) obstack_finish (&ob2);
+ if (cu->cu_intracu_form != DW_FORM_ref_udata)
+ {
+ switch (cu->cu_intracu_form)
+ {
+ case DW_FORM_ref1: intracusize = 1; break;
+ case DW_FORM_ref2: intracusize = 2; break;
+ case DW_FORM_ref4: intracusize = 4; break;
+ default: abort ();
+ }
+ off = init_new_die_offsets (cu->cu_die, headersz, intracusize);
+ }
+ else
+ {
+ intracusize = cu->initial_intracusize;
+
+ off = init_new_die_offsets (cu->cu_die, headersz, intracusize);
+ do
+ {
+ intracuvec = intracuarr;
+ i = update_new_die_offsets (cu->cu_die, headersz, &intracuvec);
+ assert (*intracuvec == NULL);
+ if (i == off)
+ break;
+ assert (i < off);
+ off = i;
+ }
+ while (1);
+
+ intracuvec = intracuarr;
+ off = finalize_new_die_offsets (cu, cu->cu_die, headersz, 0,
+ &intracuvec);
+ assert (*intracuvec == NULL);
+ }
+ obstack_free (&ob2, (void *) t);
+ assert (off == cu_size);
+}
+
+/* Construct new .debug_info section in malloced memory,
+ store it to debug_sections[DEBUG_INFO].new_data. */
+static void
+write_info (unsigned int *die_count)
+{
+ dw_cu_ref cu, cu_next;
+ unsigned char *info = malloc (debug_sections[DEBUG_INFO].new_size);
+ unsigned char *ptr = info;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_info\n");
+ }
+
+ if (info == NULL)
+ dwz_oom ();
+ if (die_count)
+ *die_count = 0;
+ debug_sections[DEBUG_INFO].new_data = info;
+ cu = first_cu;
+ if (unlikely (fi_multifile))
+ while (cu
+ && cu->cu_kind == CU_NORMAL
+ && cu->cu_die->die_remove)
+ cu = cu->cu_next;
+ for (; cu; cu = cu_next)
+ {
+ unsigned long next_off = debug_sections[DEBUG_INFO].new_size;
+ /* Ignore .debug_types CUs. */
+ if (cu->cu_kind == CU_TYPES)
+ break;
+ cu_next = cu->cu_next;
+ if (unlikely (fi_multifile))
+ while (cu_next
+ && cu_next->cu_kind == CU_NORMAL
+ && cu_next->cu_die->die_remove)
+ cu_next = cu_next->cu_next;
+ if (cu_next && cu_next->cu_kind == CU_TYPES)
+ cu_next = NULL;
+ if (cu_next)
+ next_off = cu_next->cu_new_offset;
+ else if (wr_multifile)
+ next_off += multi_info_off - 11L;
+ if (unlikely (low_mem)
+ && cu->cu_kind != CU_PU
+ && expand_children (cu->cu_die))
+ recompute_abbrevs (cu, next_off - cu->cu_new_offset);
+ /* Write CU header. */
+ write_32 (ptr, next_off - cu->cu_new_offset - 4);
+ write_16 (ptr, cu->cu_version);
+ if (cu->cu_version >= 5)
+ {
+ *ptr++ = (cu->cu_die->die_tag == DW_TAG_compile_unit
+ ? DW_UT_compile : DW_UT_partial);
+ write_8 (ptr, ptr_size);
+ }
+ write_32 (ptr, cu->u2.cu_new_abbrev_offset);
+ if (cu->cu_version < 5)
+ write_8 (ptr, ptr_size);
+ ptr = write_die (ptr, cu, cu->cu_die, NULL, NULL, die_count);
+ assert (info + (next_off - (wr_multifile ? multi_info_off : 0)) == ptr);
+ if (unlikely (low_mem) && cu->cu_kind != CU_PU)
+ collapse_children (cu, cu->cu_die);
+ }
+ if (wr_multifile)
+ {
+ /* And terminate the contribution by the current object file. */
+ write_32 (ptr, 7);
+ write_16 (ptr, 2);
+ write_32 (ptr, 0);
+ write_8 (ptr, ptr_size);
+ }
+ assert (info + debug_sections[DEBUG_INFO].new_size == ptr);
+}
+
+/* Adjust .debug_loc range determined by *SLOT, called through
+ htab_traverse. */
+static int
+adjust_loclist (void **slot, void *data)
+{
+ struct debug_loc_adjust *adj = (struct debug_loc_adjust *) *slot;
+ unsigned char *ptr, *endsec;
+ GElf_Addr low, high;
+ size_t len;
+
+ (void)data;
+
+ ptr = debug_sections[DEBUG_LOC].new_data + adj->start_offset;
+ endsec = ptr + debug_sections[DEBUG_LOC].size;
+ while (ptr < endsec)
+ {
+ low = read_size (ptr, ptr_size);
+ high = read_size (ptr + ptr_size, ptr_size);
+ ptr += 2 * ptr_size;
+ if (low == 0 && high == 0)
+ break;
+
+ if (low == ~ (GElf_Addr) 0 || (ptr_size == 4 && low == 0xffffffff))
+ continue;
+
+ len = read_16 (ptr);
+ assert (ptr + len <= endsec);
+
+ adjust_exprloc (adj->cu, adj->cu->cu_die, adj->cu, adj->cu->cu_die,
+ ptr, len);
+
+ ptr += len;
+ }
+
+ return 1;
+}
+
+/* Adjust .debug_loclists range determined by *SLOT, called through
+ htab_traverse. */
+static int
+adjust_loclists (void **slot, void *data)
+{
+ struct debug_loc_adjust *adj = (struct debug_loc_adjust *) *slot;
+ unsigned char *ptr, *endsec;
+ size_t len = 0;
+
+ (void)data;
+
+ ptr = debug_sections[DEBUG_LOCLISTS].new_data + adj->start_offset;
+ endsec = ptr + debug_sections[DEBUG_LOCLISTS].size;
+
+again:
+ while (ptr < endsec)
+ {
+ uint8_t lle = *ptr++;
+ switch (lle)
+ {
+ case DW_LLE_end_of_list:
+ goto done;
+
+ case DW_LLE_base_addressx:
+ skip_leb128 (ptr);
+ goto again;
+
+ case DW_LLE_startx_endx:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_startx_length:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_offset_pair:
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_default_location:
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_base_address:
+ ptr += ptr_size;
+ goto again;
+
+ case DW_LLE_start_end:
+ ptr += 2 * ptr_size;
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_start_length:
+ ptr += ptr_size;
+ skip_leb128 (ptr);
+ len = read_uleb128 (ptr);
+ break;
+
+ case DW_LLE_GNU_view_pair:
+ /* Note we cannot check CU version here, but we'll get a
+ warning on the original parsing if CU version is not 5.*/
+ skip_leb128 (ptr);
+ skip_leb128 (ptr);
+ goto again;
+
+ default:
+ error (0, 0, "unhandled location list entry 0x%x", lle);
+ return 1;
+ }
+
+ assert (ptr + len <= endsec);
+
+ adjust_exprloc (adj->cu, adj->cu->cu_die, adj->cu, adj->cu->cu_die,
+ ptr, len);
+
+ ptr += len;
+ }
+
+done:
+ return 1;
+}
+
+/* Create new .debug_loc section in malloced memory if .debug_loc
+ needs to be adjusted. */
+static void
+write_loc (void)
+{
+ unsigned char *loc;
+ if (loc_htab == NULL)
+ return;
+ loc = malloc (debug_sections[DEBUG_LOC].size);
+ if (loc == NULL)
+ dwz_oom ();
+ memcpy (loc, debug_sections[DEBUG_LOC].data, debug_sections[DEBUG_LOC].size);
+ debug_sections[DEBUG_LOC].new_data = loc;
+ htab_traverse (loc_htab, adjust_loclist, NULL);
+}
+
+/* Create new .debug_loclists section in malloced memory if .debug_loclists
+ needs to be adjusted. */
+static void
+write_loclists (void)
+{
+ unsigned char *loc;
+ if (loclists_htab == NULL)
+ return;
+ loc = malloc (debug_sections[DEBUG_LOCLISTS].size);
+ if (loc == NULL)
+ dwz_oom ();
+ memcpy (loc, debug_sections[DEBUG_LOCLISTS].data,
+ debug_sections[DEBUG_LOCLISTS].size);
+ debug_sections[DEBUG_LOCLISTS].new_data = loc;
+ htab_traverse (loclists_htab, adjust_loclists, NULL);
+}
+
+/* Create new .debug_types section in malloced memory. */
+static void
+write_types (void)
+{
+ dw_cu_ref cu;
+ unsigned char *types, *ptr, *inptr;
+ dw_die_ref ref;
+
+ if (debug_sections[DEBUG_TYPES].data == NULL)
+ return;
+ types = malloc (debug_sections[DEBUG_TYPES].new_size);
+ if (types == NULL)
+ dwz_oom ();
+ debug_sections[DEBUG_TYPES].new_data = types;
+ ptr = types;
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ {
+ unsigned long next_off = debug_sections[DEBUG_TYPES].new_size;
+ /* Ignore .debug_info CUs. */
+ if (cu->cu_kind != CU_TYPES)
+ continue;
+ if (cu->cu_next)
+ next_off = cu->cu_next->cu_new_offset;
+ if (unlikely (low_mem)
+ && expand_children (cu->cu_die))
+ recompute_abbrevs (cu, next_off - cu->cu_new_offset);
+ /* Write CU header. */
+ write_32 (ptr, next_off - cu->cu_new_offset - 4);
+ write_16 (ptr, cu->cu_version);
+ write_32 (ptr, cu->u2.cu_new_abbrev_offset);
+ write_8 (ptr, ptr_size);
+ inptr = debug_sections[DEBUG_TYPES].data + cu->cu_offset + 19;
+ memcpy (ptr, inptr - 8, 8);
+ ptr += 8;
+ ref = off_htab_lookup (cu, cu->cu_offset + read_32 (inptr));
+ assert (ref && die_safe_dup(ref) == NULL);
+ write_32 (ptr, ref->u.p2.die_new_offset);
+ ptr = write_die (ptr, cu, cu->cu_die, NULL, NULL, NULL);
+ assert (types + next_off == ptr);
+ if (unlikely (low_mem))
+ collapse_children (cu, cu->cu_die);
+ }
+ assert (types + debug_sections[DEBUG_TYPES].new_size == ptr);
+}
+
+/* Construct new .debug_aranges section in malloced memory,
+ store it to debug_sections[DEBUG_ARANGES].new_data. */
+static int
+write_aranges (DSO *dso)
+{
+ dw_cu_ref cu, cufirst = NULL, cucur;
+ unsigned char *aranges, *ptr, *end;
+
+ if (debug_sections[DEBUG_ARANGES].data == NULL)
+ return 0;
+
+ aranges = malloc (debug_sections[DEBUG_ARANGES].size);
+ if (aranges == NULL)
+ dwz_oom ();
+ memcpy (aranges, debug_sections[DEBUG_ARANGES].data,
+ debug_sections[DEBUG_ARANGES].size);
+ debug_sections[DEBUG_ARANGES].new_data = aranges;
+ ptr = aranges;
+ end = aranges + debug_sections[DEBUG_ARANGES].size;
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ if (cu->cu_kind != CU_PU)
+ break;
+ cufirst = cu;
+ while (ptr < end)
+ {
+ unsigned int culen, value, cuoff;
+
+ if (end - ptr < 12)
+ {
+ error (0, 0, "%s: Corrupted .debug_aranges section",
+ dso->filename);
+ return 1;
+ }
+ culen = read_32 (ptr);
+ if (culen >= 0xfffffff0)
+ {
+ error (0, 0, "%s: 64-bit DWARF not supported", dso->filename);
+ return 1;
+ }
+
+ value = read_16 (ptr);
+ if (value != 2)
+ {
+ error (0, 0, "%s: DWARF version %d in .debug_aranges unhandled",
+ dso->filename, value);
+ return 1;
+ }
+
+ cuoff = read_32 (ptr);
+ cucur = cu;
+ /* Optimistically assume that .debug_aranges CU offsets only increase,
+ otherwise this might be too expensive and need a hash table. */
+ for (; cu; cu = cu->cu_next)
+ {
+ if (cu->cu_kind == CU_TYPES)
+ {
+ cu = NULL;
+ break;
+ }
+ else if (cu->cu_offset == cuoff)
+ break;
+ }
+ if (cu == NULL)
+ {
+ for (cu = cufirst; cu != cucur; cu = cu->cu_next)
+ if (cu->cu_offset == cuoff)
+ break;
+ if (cu == cucur)
+ {
+ error (0, 0, "%s: Couldn't find CU for .debug_aranges "
+ "offset 0x%x", dso->filename, cuoff);
+ return 1;
+ }
+ }
+ if (unlikely (fi_multifile)
+ && cu->cu_kind == CU_NORMAL
+ && cu->cu_die->die_remove)
+ {
+ error (0, 0, "%s: Partial unit referenced in .debug_aranges",
+ dso->filename);
+ return 1;
+ }
+ ptr -= 4;
+ write_32 (ptr, cu->cu_new_offset);
+ ptr += culen - 6;
+ }
+ return 0;
+}
+
+/* Helper function of write_gdb_index, called through qsort.
+ Sort an array of unsigned integer pairs, by increasing
+ first integer. The first integer is the TU offset
+ in the .gdb_index TU table, the second is its index in
+ the TU table from the start of that table. */
+static int
+gdb_index_tu_cmp (const void *p, const void *q)
+{
+ unsigned int *t1 = (unsigned int *) p;
+ unsigned int *t2 = (unsigned int *) q;
+
+ if (t1[0] < t2[0])
+ return -1;
+ if (t1[0] > t2[0])
+ return 1;
+
+ if (t1[1] < t2[1])
+ return -1;
+ if (t1[1] > t2[1])
+ return 1;
+ return 0;
+}
+
+/* Construct new .gdb_index section in malloced memory
+ if it needs adjustment. */
+static void
+write_gdb_index (void)
+{
+ dw_cu_ref cu, cu_next, first_tu = NULL;
+ unsigned char *gdb_index, *ptr, *inptr, *end;
+ unsigned int ncus = 0, npus = 0, ntus = 0, ndelcus = 0, ver;
+ unsigned int culistoff, cutypesoff, addressoff, symboloff, constoff;
+ unsigned int *tuindices = NULL, tuidx = 0, *cumap = NULL, i, j, k;
+ bool fail = false;
+
+ debug_sections[GDB_INDEX].new_size = 0;
+ if (likely (!op_multifile)
+ && (debug_sections[GDB_INDEX].data == NULL
+ || debug_sections[GDB_INDEX].size < 0x18))
+ return;
+ inptr = (unsigned char *) debug_sections[GDB_INDEX].data;
+ if (unlikely (op_multifile))
+ ver = multi_gdb_index_ver;
+ else
+ ver = buf_read_ule32 (inptr);
+ if (ver < 4 || ver > 8)
+ return;
+
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ if (cu->cu_kind == CU_PU)
+ npus++;
+ else if (cu->cu_kind == CU_NORMAL)
+ {
+ ncus++;
+ if (unlikely (fi_multifile) && cu->cu_die->die_remove)
+ ndelcus++;
+ }
+ else if (cu->cu_kind == CU_TYPES)
+ ntus++;
+
+ /* Starting with version 7 CU indexes are limited to 24 bits,
+ so if we have more CUs, give up. */
+ if (npus + ncus + ntus - ndelcus >= (1U << 24))
+ return;
+
+ if (unlikely (op_multifile))
+ {
+ assert (ncus == 0 && ntus == 0);
+ debug_sections[GDB_INDEX].new_size
+ = 0x18 + npus * 16 + 16;
+ gdb_index = malloc (debug_sections[GDB_INDEX].new_size);
+ if (gdb_index == NULL)
+ dwz_oom ();
+ debug_sections[GDB_INDEX].new_data = gdb_index;
+ /* Write new header. */
+ buf_write_le32 (gdb_index + 0x00, ver);
+ buf_write_le32 (gdb_index + 0x04, 0x18);
+ buf_write_le32 (gdb_index + 0x08, 0x18 + npus * 16);
+ buf_write_le32 (gdb_index + 0x0c, 0x18 + npus * 16);
+ buf_write_le32 (gdb_index + 0x10, 0x18 + npus * 16);
+ buf_write_le32 (gdb_index + 0x14, 0x18 + npus * 16 + 16);
+ ptr = gdb_index + 0x18;
+ /* Write new CU list. */
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ {
+ unsigned long next_off = debug_sections[DEBUG_INFO].new_size;
+ if (cu->cu_next)
+ next_off = cu->cu_next->cu_new_offset;
+ buf_write_le64 (ptr, cu->cu_new_offset);
+ buf_write_le64 (ptr + 8, next_off - cu->cu_new_offset);
+ ptr += 16;
+ }
+ /* Write an empty hash table (with two entries). */
+ memset (ptr, '\0', 16);
+ return;
+ }
+
+ culistoff = buf_read_ule32 (inptr + 0x04);
+ cutypesoff = buf_read_ule32 (inptr + 0x08);
+ addressoff = buf_read_ule32 (inptr + 0x0c);
+ symboloff = buf_read_ule32 (inptr + 0x10);
+ constoff = buf_read_ule32 (inptr + 0x14);
+ if (culistoff != 0x18
+ || cutypesoff != 0x18 + ncus * 16
+ || addressoff != cutypesoff + ntus * 24
+ || symboloff < addressoff
+ || ((symboloff - addressoff) % 20) != 0
+ || constoff < symboloff
+ || ((constoff - symboloff) & (constoff - symboloff - 1)) != 0
+ || ((constoff - symboloff) & 7) != 0
+ || debug_sections[GDB_INDEX].size < constoff)
+ return;
+ inptr += 0x18;
+ if (ndelcus)
+ cumap = (unsigned int *)
+ obstack_alloc (&ob2, ncus * sizeof (unsigned int));
+ for (cu = first_cu, i = 0, j = 0; cu; cu = cu->cu_next)
+ if (cu->cu_kind == CU_NORMAL)
+ {
+ if (buf_read_ule64 (inptr) != cu->cu_offset)
+ {
+ if (cumap)
+ obstack_free (&ob2, (void *) cumap);
+ return;
+ }
+ inptr += 16;
+ if (cumap)
+ {
+ if (cu->cu_die->die_remove)
+ cumap[i++] = -1U;
+ else
+ cumap[i++] = j++;
+ }
+ }
+ else if (cu->cu_kind == CU_TYPES)
+ {
+ if (tuindices == NULL)
+ {
+ tuindices = (unsigned int *)
+ obstack_alloc (&ob2, ntus * 2 * sizeof (unsigned int));
+ first_tu = cu;
+ }
+ tuindices[2 * tuidx] = buf_read_ule64 (inptr);
+ tuindices[2 * tuidx + 1] = tuidx * 24;
+ tuidx++;
+ inptr += 24;
+ }
+ if (ntus)
+ {
+ qsort (tuindices, ntus, 2 * sizeof (unsigned int), gdb_index_tu_cmp);
+ for (tuidx = 0, cu = first_tu; tuidx < ntus; tuidx++, cu = cu->cu_next)
+ if (tuindices[2 * tuidx] != cu->cu_offset)
+ {
+ if (cumap)
+ obstack_free (&ob2, (void *) cumap);
+ else
+ obstack_free (&ob2, (void *) tuindices);
+ return;
+ }
+ }
+
+ if (multifile
+ && !fi_multifile
+ && !low_mem
+ && multi_gdb_index_ver < ver)
+ multi_gdb_index_ver = ver;
+
+ debug_sections[GDB_INDEX].new_size
+ = debug_sections[GDB_INDEX].size + npus * 16 - ndelcus * 16;
+ gdb_index = malloc (debug_sections[GDB_INDEX].new_size);
+ if (gdb_index == NULL)
+ dwz_oom ();
+ debug_sections[GDB_INDEX].new_data = gdb_index;
+ /* Write new header. */
+ buf_write_le32 (gdb_index + 0x00, ver);
+ buf_write_le32 (gdb_index + 0x04, culistoff);
+ buf_write_le32 (gdb_index + 0x08, cutypesoff + npus * 16 - ndelcus * 16);
+ buf_write_le32 (gdb_index + 0x0c, addressoff + npus * 16 - ndelcus * 16);
+ buf_write_le32 (gdb_index + 0x10, symboloff + npus * 16 - ndelcus * 16);
+ buf_write_le32 (gdb_index + 0x14, constoff + npus * 16 - ndelcus * 16);
+ ptr = gdb_index + 0x18;
+ /* Write new CU list. */
+ for (cu = first_cu; cu; cu = cu_next)
+ {
+ unsigned long next_off = debug_sections[DEBUG_INFO].new_size;
+ if (cu->cu_kind == CU_TYPES)
+ break;
+ cu_next = cu->cu_next;
+ if (unlikely (fi_multifile))
+ {
+ while (cu_next
+ && cu_next->cu_kind == CU_NORMAL
+ && cu_next->cu_die->die_remove)
+ cu_next = cu_next->cu_next;
+ if (cu->cu_die->die_remove)
+ continue;
+ }
+ if (cu_next && cu_next->cu_kind != CU_TYPES)
+ next_off = cu_next->cu_new_offset;
+ buf_write_le64 (ptr, cu->cu_new_offset);
+ buf_write_le64 (ptr + 8, next_off - cu->cu_new_offset);
+ ptr += 16;
+ }
+ /* Write new TU list. */
+ for (tuidx = 0; cu; cu = cu->cu_next, tuidx++)
+ {
+ unsigned char *p;
+ unsigned int tuoff = tuindices[2 * tuidx + 1];
+ dw_die_ref ref;
+ assert (cu->cu_kind == CU_TYPES);
+ buf_write_le64 (ptr + tuoff, cu->cu_new_offset);
+ p = debug_sections[DEBUG_TYPES].data + cu->cu_offset + 19;
+ ref = off_htab_lookup (cu, cu->cu_offset + read_32 (p));
+ assert (ref && ref->die_dup == NULL);
+ buf_write_le64 (ptr + tuoff + 8, ref->u.p2.die_new_offset);
+ p -= 12;
+ buf_write_le64 (ptr + tuoff + 16, read_64 (p));
+ }
+ ptr += ntus * 24;
+ end = inptr + (symboloff - addressoff);
+ /* Copy address area, adjusting all CU indexes. */
+ while (inptr < end)
+ {
+ memcpy (ptr, inptr, 16);
+ i = buf_read_ule32 (inptr + 16);
+ if (cumap && i < ncus)
+ {
+ if (cumap[i] == -1U)
+ fail = true;
+ i = cumap[i] + npus;
+ }
+ else
+ i += npus - ndelcus;
+ buf_write_le32 (ptr + 16, i);
+ ptr += 20;
+ inptr += 20;
+ }
+ /* Copy the symbol hash table. */
+ memcpy (ptr, inptr, constoff - symboloff);
+ /* Clear the const pool initially. */
+ memset (ptr + (constoff - symboloff), '\0',
+ debug_sections[GDB_INDEX].size - constoff);
+ ptr = ptr + (constoff - symboloff);
+ end = inptr + (constoff - symboloff);
+ /* Finally copy over const objects into the const pool, strings as is,
+ CU vectors with CU indexes adjusted. */
+ while (inptr < end)
+ {
+ unsigned int name = buf_read_ule32 (inptr);
+ unsigned int cuvec = buf_read_ule32 (inptr + 4);
+
+ inptr += 8;
+ if (name == 0 && cuvec == 0)
+ continue;
+ if (name > debug_sections[GDB_INDEX].size - constoff - 1
+ || cuvec > debug_sections[GDB_INDEX].size - constoff - 4)
+ {
+ fail:
+ free (gdb_index);
+ debug_sections[GDB_INDEX].new_size = 0;
+ return;
+ }
+ if (ptr[name] == '\0')
+ {
+ unsigned char *strend = end + name;
+ while (*strend != '\0')
+ {
+ if (strend + 1
+ == end + (debug_sections[GDB_INDEX].size - constoff))
+ goto fail;
+ strend++;
+ }
+ memcpy (ptr + name, end + name, strend + 1 - (end + name));
+ }
+ if (buf_read_ule32 (ptr + cuvec) == 0)
+ {
+ unsigned int count = buf_read_ule32 (end + cuvec);
+ if (count * 4
+ > debug_sections[GDB_INDEX].size - constoff - cuvec - 4)
+ goto fail;
+ buf_write_le32 (ptr + cuvec, count);
+ for (i = 0; i < count; i++)
+ {
+ j = buf_read_ule32 (end + cuvec + (i + 1) * 4);
+ if (ver >= 7)
+ k = j & ((1U << 24) - 1);
+ else
+ k = j;
+ if (cumap && k < ncus)
+ {
+ if (cumap[k] == -1U)
+ fail = true;
+ k = cumap[k] + npus;
+ }
+ else
+ k += npus - ndelcus;
+ if (ver >= 7)
+ j = (j & (~0U << 24)) | k;
+ else
+ j = k;
+ buf_write_le32 (ptr + cuvec + (i + 1) * 4, j);
+ }
+ }
+ }
+ if (cumap)
+ obstack_free (&ob2, (void *) cumap);
+ else if (tuindices)
+ obstack_free (&ob2, (void *) tuindices);
+ if (fail)
+ {
+ free (debug_sections[GDB_INDEX].new_data);
+ debug_sections[GDB_INDEX].new_data = NULL;
+ debug_sections[GDB_INDEX].new_size = 0;
+ }
+}
+
+/* Return a string from section SEC at offset OFFSET. */
+static const char *
+strptr (DSO *dso, int sec, off_t offset)
+{
+ Elf_Scn *scn;
+ Elf_Data *data;
+
+ scn = dso->scn[sec];
+ if (offset >= 0 && (GElf_Addr) offset < dso->shdr[sec].sh_size)
+ {
+ data = NULL;
+ while ((data = elf_rawdata (scn, data)) != NULL)
+ {
+ if (data->d_buf
+ && offset >= data->d_off
+ && offset < (off_t) (data->d_off + data->d_size))
+ return (const char *) data->d_buf + (offset - data->d_off);
+ }
+ }
+
+ return NULL;
+}
+
+/* Initialize do_read_* and do_write_* callbacks based on
+ ENDIANITY. */
+static void
+init_endian (int endianity)
+{
+ if (endianity == ELFDATA2LSB)
+ {
+ do_read_16 = buf_read_ule16;
+ do_read_32 = buf_read_ule32;
+ do_read_64 = buf_read_ule64;
+ do_write_16 = buf_write_le16;
+ do_write_32 = buf_write_le32;
+ do_write_64 = buf_write_le64;
+ }
+ else if (endianity == ELFDATA2MSB)
+ {
+ do_read_16 = buf_read_ube16;
+ do_read_32 = buf_read_ube32;
+ do_read_64 = buf_read_ube64;
+ do_write_16 = buf_write_be16;
+ do_write_32 = buf_write_be32;
+ do_write_64 = buf_write_be64;
+ }
+ else
+ abort ();
+}
+
+/* Read DWARF sections from DSO. */
+static int
+read_dwarf (DSO *dso, bool quieter, unsigned int *die_count)
+{
+ Elf_Data *data;
+ Elf_Scn *scn;
+ int i, j;
+
+ for (i = 1; i < dso->ehdr.e_shnum; ++i)
+ if (! (dso->shdr[i].sh_flags & (SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR))
+ && dso->shdr[i].sh_size)
+ {
+ const char *name = strptr (dso, dso->ehdr.e_shstrndx,
+ dso->shdr[i].sh_name);
+
+ if (strncmp (name, ".debug_", sizeof (".debug_") - 1) == 0
+ || strcmp (name, ".gdb_index") == 0
+ || strcmp (name, ".gnu_debugaltlink") == 0)
+ {
+ if (dso->shdr[i].sh_flags & SHF_COMPRESSED)
+ {
+ error (0, 0,
+ "%s: Found compressed %s section, not attempting dwz"
+ " compression",
+ dso->filename, name);
+ return 1;
+ }
+ for (j = 0; debug_sections[j].name; ++j)
+ if (strcmp (name, debug_sections[j].name) == 0)
+ {
+ if (debug_sections[j].data)
+ {
+ error (0, 0, "%s: Found two copies of %s section",
+ dso->filename, name);
+ return 1;
+ }
+
+ scn = dso->scn[i];
+ data = elf_rawdata (scn, NULL);
+ assert (data != NULL);
+ if (data->d_buf == NULL)
+ {
+ error (0, 0, "%s: Found empty %s section, not attempting"
+ " dwz compression", dso->filename, name);
+ return 1;
+ }
+ assert (elf_rawdata (scn, data) == NULL);
+ assert (data->d_off == 0);
+ assert (data->d_size == dso->shdr[i].sh_size);
+ debug_sections[j].data = data->d_buf;
+ debug_sections[j].size = data->d_size;
+ debug_sections[j].new_size = data->d_size;
+ debug_sections[j].sec = i;
+ break;
+ }
+
+ if (debug_sections[j].name == NULL)
+ {
+ error (0, 0, "%s: Unknown debugging section %s",
+ dso->filename, name);
+ return 1;
+ }
+ }
+ }
+
+ if (dso->ehdr.e_ident[EI_DATA] == ELFDATA2LSB
+ || dso->ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
+ init_endian (dso->ehdr.e_ident[EI_DATA]);
+ else
+ {
+ error (0, 0, "%s: Wrong ELF data encoding", dso->filename);
+ return 1;
+ }
+
+ if (debug_sections[DEBUG_INFO].data == NULL
+ && !rd_multifile)
+ {
+ if (!quieter)
+ error (0, 0, "%s: .debug_info section not present",
+ dso->filename);
+ return 3;
+ }
+
+ if (debug_sections[DEBUG_SUP].data != NULL && !(dwarf_5 && rd_multifile))
+ {
+ error (0, 0, "%s: .debug_sup section already present",
+ dso->filename);
+ return 1;
+ }
+
+ if (debug_sections[GNU_DEBUGALTLINK].data != NULL)
+ {
+ error (0, 0, "%s: .gnu_debugaltlink section already present",
+ dso->filename);
+ return 1;
+ }
+
+ int res;
+ res = read_debug_info (dso, DEBUG_INFO, die_count);
+ if (res == 0 && stats_p)
+ print_parse_stats ();
+ return res;
+}
+
+/* Open an ELF file NAME. */
+static DSO *
+fdopen_dso (int fd, const char *name)
+{
+ Elf *elf = NULL;
+ GElf_Ehdr ehdr;
+ int i;
+ DSO *dso = NULL;
+
+ elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
+ if (elf == NULL)
+ {
+ error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1));
+ goto error_out;
+ }
+
+ if (elf_kind (elf) != ELF_K_ELF)
+ {
+ error (0, 0, "\"%s\" is not an ELF file", name);
+ goto error_out;
+ }
+
+ if (gelf_getehdr (elf, &ehdr) == NULL)
+ {
+ error (0, 0, "cannot get the ELF header: %s",
+ elf_errmsg (-1));
+ goto error_out;
+ }
+
+ if (ehdr.e_type != ET_DYN && ehdr.e_type != ET_EXEC
+ && (!rd_multifile || ehdr.e_type != ET_REL))
+ {
+ error (0, 0, "\"%s\" is not a shared library", name);
+ goto error_out;
+ }
+
+ /* Allocate DSO structure. */
+ dso = (DSO *)
+ malloc (sizeof(DSO) + ehdr.e_shnum * sizeof(GElf_Shdr)
+ + ehdr.e_shnum * sizeof(Elf_Scn *)
+ + strlen (name) + 1);
+ if (!dso)
+ {
+ error (0, ENOMEM, "Could not open DSO");
+ goto error_out;
+ }
+
+ elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT | ELF_F_PERMISSIVE);
+
+ memset (dso, 0, sizeof(DSO));
+ dso->elf = elf;
+ dso->ehdr = ehdr;
+ dso->scn = (Elf_Scn **) &dso->shdr[ehdr.e_shnum];
+
+ for (i = 0; i < ehdr.e_shnum; ++i)
+ {
+ dso->scn[i] = elf_getscn (elf, i);
+ gelf_getshdr (dso->scn[i], dso->shdr + i);
+ }
+
+ dso->filename = (const char *) &dso->scn[ehdr.e_shnum];
+ strcpy ((char *) &dso->scn[ehdr.e_shnum], name);
+ return dso;
+
+error_out:
+ free (dso);
+ if (elf)
+ elf_end (elf);
+ if (fd != -1)
+ close (fd);
+ return NULL;
+}
+
+/* Implicit arg for compare_section_numbers. Could be passed in as explicit arg
+ when using qsort_r instead. */
+static DSO *compare_section_numbers_implicit_arg;
+
+/* Helper function for sort_section_numbers. */
+static int
+compare_section_numbers (const void *p1, const void *p2)
+{
+ DSO *dso = compare_section_numbers_implicit_arg;
+ const int i1 = *(const int *)p1;
+ const int i2 = *(const int *)p2;
+ GElf_Off o1;
+ GElf_Off o2;
+
+ /* Keep element 0 at 0. */
+ if (i1 == 0 || i2 == 0)
+ {
+ if (i1 == i2)
+ return 0;
+ if (i1 == 0)
+ return -1;
+ if (i2 == 0)
+ return 1;
+ }
+
+ /* Get file offsets. */
+ o1 = (i1 == dso->ehdr.e_shnum
+ ? dso->ehdr.e_shoff
+ : dso->shdr[i1].sh_offset);
+ o2 = (i2 == dso->ehdr.e_shnum
+ ? dso->ehdr.e_shoff
+ : dso->shdr[i2].sh_offset);
+
+ /* Compare file offsets. */
+ if (o1 < o2)
+ return -1;
+ if (o1 > o2)
+ return 1;
+
+ /* In case file offset is the same, keep the original relative order. */
+ if (i1 < i2)
+ return -1;
+ if (i1 > i2)
+ return 1;
+
+ return 0;
+}
+
+/* Sort SORTED_SECTION_NUMBERS in file offset order. */
+static void
+sort_section_numbers (DSO *dso, unsigned int *sorted_section_numbers)
+{
+ unsigned int i;
+ unsigned int nr_sections = dso->ehdr.e_shnum;
+
+ /* Treat section header table as another section, with index
+ dso->ehdr.e_shnum. */
+ nr_sections += 1;
+
+ for (i = 0; i < nr_sections; ++i)
+ sorted_section_numbers[i] = i;
+
+ compare_section_numbers_implicit_arg = dso;
+ qsort (sorted_section_numbers, nr_sections,
+ sizeof (sorted_section_numbers[0]), compare_section_numbers);
+ compare_section_numbers_implicit_arg = NULL;
+
+ assert (sorted_section_numbers[0] == 0);
+}
+
+/* Verify file offset and size of sections and section header table. */
+static void
+verify_sections (DSO *dso, unsigned int *sorted_section_numbers,
+ GElf_Off *distance, int addsec, GElf_Off addsize,
+ GElf_Ehdr ehdr)
+{
+ int i, j;
+ int prev, update_prev;
+ GElf_Off offset, prev_offset, prev_size;
+ GElf_Off section_header_table_size
+ = dso->ehdr.e_shentsize * ehdr.e_shnum;
+
+ prev = -1;
+ for (i = 1; i < (dso->ehdr.e_shnum + 1); ++i, prev = update_prev)
+ {
+ j = sorted_section_numbers[i];
+
+ if (j != dso->ehdr.e_shnum && dso->shdr[j].sh_type == SHT_NOBITS)
+ {
+ update_prev = prev;
+ continue;
+ }
+ update_prev = j;
+
+ if (prev == -1)
+ continue;
+
+ offset = (j == dso->ehdr.e_shnum
+ ? ehdr.e_shoff
+ : dso->shdr[j].sh_offset);
+
+ prev_offset = (prev == dso->ehdr.e_shnum
+ ? ehdr.e_shoff
+ : dso->shdr[prev].sh_offset);
+
+ prev_size = (prev == dso->ehdr.e_shnum
+ ? section_header_table_size
+ : (dso->shdr[prev].sh_type == SHT_NOBITS
+ ? 0
+ : dso->shdr[prev].sh_size));
+
+ if (distance != NULL)
+ assert ((prev_offset + prev_size + distance[prev]
+ + (prev == addsec ? addsize : 0))
+ == offset);
+ else
+ assert ((prev_offset + prev_size + (prev == addsec ? addsize : 0))
+ <= offset);
+ }
+}
+
+/* Calculate distance between sections and section header table. */
+static int
+calculate_section_distance (DSO *dso, unsigned int *sorted_section_numbers,
+ GElf_Off *distance)
+{
+ int i, j;
+ int prev, update_prev;
+ GElf_Off offset, prev_offset, prev_size;
+ GElf_Off section_header_table_size
+ = dso->ehdr.e_shentsize * dso->ehdr.e_shnum;
+
+ prev = -1;
+ for (i = 1; i < (dso->ehdr.e_shnum + 1); ++i, prev = update_prev)
+ {
+ j = sorted_section_numbers[i];
+
+ if (j != dso->ehdr.e_shnum && dso->shdr[j].sh_type == SHT_NOBITS)
+ {
+ update_prev = prev;
+ continue;
+ }
+ update_prev = j;
+
+ if (prev == -1)
+ continue;
+
+ offset = (j == dso->ehdr.e_shnum
+ ? dso->ehdr.e_shoff
+ : dso->shdr[j].sh_offset);
+
+ prev_offset = (prev == dso->ehdr.e_shnum
+ ? dso->ehdr.e_shoff
+ : dso->shdr[prev].sh_offset);
+
+ prev_size = (prev == dso->ehdr.e_shnum
+ ? section_header_table_size
+ : dso->shdr[prev].sh_size);
+
+ if (prev_offset + prev_size > offset)
+ {
+ error (0, 0, "Section overlap detected");
+ if (prev == dso->ehdr.e_shnum)
+ error (0, 0, "Section header table: [0x%llx, 0x%llx)",
+ (unsigned long long)prev_offset,
+ (unsigned long long)(prev_offset + prev_size));
+ else
+ error (0, 0, "Section %d: [0x%llx, 0x%llx)", j,
+ (unsigned long long)prev_offset,
+ (unsigned long long)(prev_offset + prev_size));
+ if (j == dso->ehdr.e_shnum)
+ error (0, 0, "Section header table: 0x%llx",
+ (unsigned long long)offset);
+ else
+ error (0, 0, "Section %d: 0x%llx", j, (unsigned long long)offset);
+ return 1;
+ }
+
+ distance[prev] = offset - (prev_offset + prev_size);
+ }
+
+ verify_sections (dso, sorted_section_numbers, distance, -1, 0, dso->ehdr);
+
+ return 0;
+}
+
+/* Store new ELF into FILE. debug_sections array contains
+ new_data/new_size pairs where needed. */
+static int
+write_dso (DSO *dso, const char *file, struct stat *st, bool save_to_temp)
+{
+ Elf *elf = NULL;
+ GElf_Ehdr ehdr;
+ GElf_Off min_shoff = ~(GElf_Off) 0;
+ char *e_ident;
+ int fd, i, j, addsec = -1, ret;
+ GElf_Off off, diff, addsize = 0;
+ char *filename = NULL;
+ GElf_Word shstrtabadd = 0;
+ char *shstrtab = NULL;
+ bool remove_sections[SECTION_COUNT];
+ GElf_Off distance[dso->ehdr.e_shnum + 1];
+ /* Array of sections and section header table sorted by file offset. */
+ unsigned int sorted_section_numbers[dso->ehdr.e_shnum + 1];
+ GElf_Off old_sh_offset[dso->ehdr.e_shnum];
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_dso\n");
+ }
+
+ for (i = 1; i < dso->ehdr.e_shnum; ++i)
+ old_sh_offset[i] = dso->shdr[i].sh_offset;
+
+ memset (remove_sections, '\0', sizeof (remove_sections));
+ ehdr = dso->ehdr;
+
+ sort_section_numbers (dso, sorted_section_numbers);
+ if (calculate_section_distance (dso, sorted_section_numbers, distance))
+ return 1;
+
+ for (i = 0; debug_sections[i].name; i++)
+ if (debug_sections[i].new_size != debug_sections[i].size)
+ {
+ if (debug_sections[i].size == 0
+ && debug_sections[i].sec == 0)
+ {
+ unsigned int len;
+ if (addsec == -1)
+ for (j = 0; debug_sections[j].name; j++)
+ if (debug_sections[j].new_size
+ && debug_sections[j].sec
+ && debug_sections[j].sec > addsec)
+ addsec = debug_sections[j].sec;
+ ehdr.e_shnum++;
+ if (ehdr.e_shoff < min_shoff)
+ min_shoff = ehdr.e_shoff;
+ for (j = 1; j < dso->ehdr.e_shnum; ++j)
+ {
+ if (dso->shdr[j].sh_offset > ehdr.e_shoff)
+ dso->shdr[j].sh_offset += ehdr.e_shentsize;
+ if (dso->shdr[j].sh_link > (unsigned int) addsec)
+ dso->shdr[j].sh_link++;
+ if ((dso->shdr[j].sh_type == SHT_REL
+ || dso->shdr[j].sh_type == SHT_RELA
+ || (dso->shdr[j].sh_flags & SHF_INFO_LINK))
+ && dso->shdr[j].sh_info
+ > (unsigned int) addsec)
+ dso->shdr[j].sh_info++;
+ }
+ if (dso->ehdr.e_shstrndx > addsec)
+ ehdr.e_shstrndx++;
+ len = strlen (debug_sections[i].name) + 1;
+ dso->shdr[dso->ehdr.e_shstrndx].sh_size += len;
+ if (dso->shdr[dso->ehdr.e_shstrndx].sh_offset < min_shoff)
+ min_shoff = dso->shdr[dso->ehdr.e_shstrndx].sh_offset;
+ for (j = 1; j < dso->ehdr.e_shnum; ++j)
+ if (dso->shdr[j].sh_offset
+ > dso->shdr[dso->ehdr.e_shstrndx].sh_offset)
+ dso->shdr[j].sh_offset += len;
+ if (ehdr.e_shoff > dso->shdr[dso->ehdr.e_shstrndx].sh_offset)
+ ehdr.e_shoff += len;
+ shstrtabadd += len;
+ diff = debug_sections[i].new_size;
+ addsize += diff;
+ off = dso->shdr[addsec].sh_offset;
+ }
+ else
+ {
+ diff = (GElf_Off) debug_sections[i].new_size
+ - (GElf_Off) dso->shdr[debug_sections[i].sec].sh_size;
+ off = dso->shdr[debug_sections[i].sec].sh_offset;
+ }
+ if (off < min_shoff)
+ min_shoff = off;
+ for (j = 1; j < dso->ehdr.e_shnum; ++j)
+ if (dso->shdr[j].sh_offset > off)
+ dso->shdr[j].sh_offset += diff;
+ if (ehdr.e_shoff > off)
+ ehdr.e_shoff += diff;
+ dso->shdr[debug_sections[i].sec].sh_size
+ = debug_sections[i].new_size;
+ if (debug_sections[i].new_size == 0)
+ {
+ remove_sections[i] = true;
+ ehdr.e_shnum--;
+ if (ehdr.e_shoff < min_shoff)
+ min_shoff = ehdr.e_shoff;
+ for (j = 1; j < dso->ehdr.e_shnum; ++j)
+ {
+ if (dso->shdr[j].sh_offset > ehdr.e_shoff)
+ dso->shdr[j].sh_offset -= ehdr.e_shentsize;
+ if (dso->shdr[j].sh_link
+ > (unsigned int) debug_sections[i].sec)
+ dso->shdr[j].sh_link--;
+ if ((dso->shdr[j].sh_type == SHT_REL
+ || dso->shdr[j].sh_type == SHT_RELA
+ || (dso->shdr[j].sh_flags & SHF_INFO_LINK))
+ && dso->shdr[j].sh_info
+ > (unsigned int) debug_sections[i].sec)
+ dso->shdr[j].sh_info--;
+ }
+ if (dso->ehdr.e_shstrndx > debug_sections[i].sec)
+ ehdr.e_shstrndx--;
+ }
+ }
+
+ /* Verify that we did not change section layout, by checking that the
+ distances between sections and section header table remained the same. */
+ verify_sections (dso, sorted_section_numbers, distance, addsec, addsize,
+ ehdr);
+
+ if (min_shoff != ~(GElf_Off) 0)
+ {
+ for (j = 1; j < dso->ehdr.e_shnum; ++j)
+ if (dso->shdr[j].sh_offset >= min_shoff
+ && dso->shdr[j].sh_addralign > 1
+ && (dso->shdr[j].sh_offset & (dso->shdr[j].sh_addralign - 1)) != 0)
+ break;
+ if (j < dso->ehdr.e_shnum
+ || (ehdr.e_shoff >= min_shoff
+ && (ehdr.e_shoff & (ehdr.e_ident[EI_CLASS] == ELFCLASS64
+ ? 7 : 3)) != 0))
+ {
+ /* Need to fix up sh_offset/e_shoff. Punt if all the sections
+ >= min_shoff aren't non-ALLOC. */
+ GElf_Off last_shoff = 0;
+ int k = -1;
+ int l;
+ for (l = 1; l <= dso->ehdr.e_shnum; ++l)
+ {
+ j = sorted_section_numbers[l];
+ if (j == dso->ehdr.e_shnum)
+ continue;
+ else if (!last_shoff
+ && (dso->shdr[j].sh_offset < min_shoff
+ || (dso->shdr[j].sh_offset == min_shoff
+ && (dso->shdr[j].sh_size == 0
+ || dso->shdr[j].sh_type == SHT_NOBITS))))
+ continue;
+ else if (dso->shdr[j].sh_type == SHT_NOBITS)
+ continue;
+ else if ((dso->shdr[j].sh_flags & SHF_ALLOC) != 0)
+ {
+ error (0, 0, "Allocatable section in %s after "
+ "non-allocatable ones", dso->filename);
+ return 1;
+ }
+ else
+ {
+ assert (dso->shdr[j].sh_offset >= last_shoff);
+
+ if (k == -1)
+ k = l;
+ last_shoff = dso->shdr[j].sh_offset + dso->shdr[j].sh_size;
+ }
+ }
+ last_shoff = min_shoff;
+ for (l = k; l <= dso->ehdr.e_shnum; ++l)
+ {
+ j = sorted_section_numbers[l];
+ if (j == dso->ehdr.e_shnum)
+ {
+ if (ehdr.e_ident[EI_CLASS] == ELFCLASS64)
+ ehdr.e_shoff = (last_shoff + 7) & -8;
+ else
+ ehdr.e_shoff = (last_shoff + 3) & -4;
+ last_shoff = ehdr.e_shoff + ehdr.e_shnum * ehdr.e_shentsize;
+ continue;
+ }
+ /* Ignore SHT_NOBITS sections. */
+ if (dso->shdr[j].sh_type == SHT_NOBITS)
+ continue;
+ dso->shdr[j].sh_offset = last_shoff;
+ if (dso->shdr[j].sh_addralign > 1)
+ dso->shdr[j].sh_offset
+ = (last_shoff + dso->shdr[j].sh_addralign - 1)
+ & ~(dso->shdr[j].sh_addralign - (GElf_Off) 1);
+ last_shoff = dso->shdr[j].sh_offset + dso->shdr[j].sh_size;
+ if (addsec != -1 && j == addsec)
+ last_shoff += addsize;
+ }
+ }
+ }
+
+ for (i = 1; i < dso->ehdr.e_shnum; ++i)
+ if (dso->shdr[i].sh_type == SHT_NOBITS)
+ dso->shdr[i].sh_offset = old_sh_offset[i];
+
+ verify_sections (dso, sorted_section_numbers, NULL, addsec, addsize,
+ ehdr);
+
+ if (shstrtabadd != 0)
+ {
+ shstrtab = (char *) malloc (dso->shdr[dso->ehdr.e_shstrndx].sh_size);
+ if (shstrtab == NULL)
+ {
+ error (0, ENOMEM, "Failed to adjust .shstrtab for %s",
+ dso->filename);
+ return 1;
+ }
+ }
+
+ if (file == NULL)
+ {
+ size_t len = strlen (dso->filename);
+ filename = alloca (len + sizeof (".#dwz#.XXXXXX"));
+ memcpy (filename, dso->filename, len);
+ memcpy (filename + len, ".#dwz#.XXXXXX", sizeof (".#dwz#.XXXXXX"));
+ fd = mkstemp (filename);
+ file = (const char *) filename;
+ if (fd == -1)
+ {
+ error (0, errno, "Failed to create temporary file for %s",
+ dso->filename);
+ free (shstrtab);
+ return 1;
+ }
+ }
+ else
+ {
+ fd = open (file, O_RDWR | O_CREAT, 0600);
+ if (fd == -1)
+ {
+ error (0, errno, "Failed to open %s for writing", file);
+ free (shstrtab);
+ return 1;
+ }
+ }
+
+ elf = elf_begin (fd, ELF_C_WRITE, NULL);
+ if (elf == NULL)
+ {
+ error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1));
+ unlink (file);
+ close (fd);
+ free (shstrtab);
+ return 1;
+ }
+
+ /* Some gelf_newehdr implementations don't return the resulting
+ ElfNN_Ehdr, so we have to do it the hard way instead of:
+ e_ident = (char *) gelf_newehdr (elf, gelf_getclass (dso->elf)); */
+ switch (gelf_getclass (dso->elf))
+ {
+ case ELFCLASS32:
+ e_ident = (char *) elf32_newehdr (elf);
+ break;
+ case ELFCLASS64:
+ e_ident = (char *) elf64_newehdr (elf);
+ break;
+ default:
+ e_ident = NULL;
+ break;
+ }
+
+ if (e_ident == NULL
+ /* This is here just for the gelfx wrapper, so that gelf_update_ehdr
+ already has the correct ELF class. */
+ || memcpy (e_ident, dso->ehdr.e_ident, EI_NIDENT) == NULL
+ || gelf_update_ehdr (elf, &ehdr) == 0
+ || gelf_newphdr (elf, ehdr.e_phnum) == 0)
+ {
+ error (0, 0, "Could not create new ELF headers");
+ unlink (file);
+ elf_end (elf);
+ close (fd);
+ free (shstrtab);
+ return 1;
+ }
+ elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT | ELF_F_PERMISSIVE);
+ for (i = 0; i < ehdr.e_phnum; ++i)
+ {
+ GElf_Phdr *phdr, phdr_mem;
+ phdr = gelf_getphdr (dso->elf, i, &phdr_mem);
+ gelf_update_phdr (elf, i, phdr);
+ }
+
+ for (i = 1; i < dso->ehdr.e_shnum; ++i)
+ {
+ Elf_Scn *scn;
+ Elf_Data *data1, *data2;
+
+ for (j = 0; debug_sections[j].name; j++)
+ if (i == debug_sections[j].sec)
+ break;
+ if (debug_sections[j].name && remove_sections[j])
+ continue;
+ scn = elf_newscn (elf);
+ elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+ gelf_update_shdr (scn, &dso->shdr[i]);
+ data1 = elf_getdata (dso->scn[i], NULL);
+ data2 = elf_newdata (scn);
+ memcpy (data2, data1, sizeof (*data1));
+ if (debug_sections[j].name
+ && debug_sections[j].new_data != NULL)
+ {
+ data2->d_buf = debug_sections[j].new_data;
+ data2->d_size = dso->shdr[i].sh_size;
+ }
+ if (i == dso->ehdr.e_shstrndx && shstrtabadd)
+ {
+ memcpy (shstrtab, data1->d_buf,
+ dso->shdr[dso->ehdr.e_shstrndx].sh_size
+ - shstrtabadd);
+ data2->d_buf = shstrtab;
+ data2->d_size = dso->shdr[i].sh_size;
+ }
+ if (i == addsec)
+ {
+ GElf_Word sh_name = dso->shdr[dso->ehdr.e_shstrndx].sh_size
+ - shstrtabadd;
+ GElf_Shdr shdr;
+
+ off = dso->shdr[i].sh_offset + dso->shdr[i].sh_size;
+ for (j = 0; debug_sections[j].name; j++)
+ if (debug_sections[j].new_size
+ && debug_sections[j].size == 0
+ && debug_sections[j].sec == 0)
+ {
+ scn = elf_newscn (elf);
+ elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+ memset (&shdr, '\0', sizeof (shdr));
+ shdr.sh_name = sh_name;
+ sh_name += strlen (debug_sections[j].name) + 1;
+ strcpy (shstrtab + shdr.sh_name, debug_sections[j].name);
+ shdr.sh_type = SHT_PROGBITS;
+ shdr.sh_offset = off;
+ shdr.sh_size = debug_sections[j].new_size;
+ shdr.sh_addralign = 1;
+ off += shdr.sh_size;
+ gelf_update_shdr (scn, &shdr);
+ data2 = elf_newdata (scn);
+ data2->d_buf = debug_sections[j].new_data;
+ data2->d_type = ELF_T_BYTE;
+ data2->d_version = EV_CURRENT;
+ data2->d_size = shdr.sh_size;
+ data2->d_off = 0;
+ data2->d_align = 1;
+ }
+ }
+ }
+
+ if (elf_update (elf, ELF_C_WRITE_MMAP) == -1)
+ {
+ error (0, 0, "%s: elf_update failed", dso->filename);
+ unlink (file);
+ elf_end (elf);
+ close (fd);
+ free (shstrtab);
+ return 1;
+ }
+
+ if (elf_end (elf) < 0)
+ {
+ error (0, 0, "elf_end failed: %s", elf_errmsg (elf_errno ()));
+ unlink (file);
+ elf_end (elf);
+ close (fd);
+ free (shstrtab);
+ return 1;
+ }
+
+ free (shstrtab);
+ ret = fchown (fd, st->st_uid, st->st_gid);
+ fchmod (fd, st->st_mode & 07777);
+ close (fd);
+
+ if (filename != NULL && rename (filename, dso->filename))
+ {
+ error (0, errno, "Failed to rename temporary file over %s",
+ dso->filename);
+ unlink (file);
+ /* | (ret & 1) to silence up __wur warning for fchown. */
+ return 1 | (ret & 1);
+ }
+ if (save_to_temp)
+ {
+ const char *prefix = "dwz.";
+ size_t buf_len = strlen (prefix) + strlen (dso->filename) + 1;
+ char *buf = (char *)alloca (buf_len);
+ size_t offset = 0;
+ strcpy (&buf[offset], prefix);
+ offset += strlen (prefix);
+ strcpy (&buf[offset], dso->filename);
+ offset += strlen (dso->filename);
+ assert (offset == buf_len - 1);
+ assert (buf[offset] == '\0');
+ unlink (buf);
+ if (link (dso->filename, buf) != 0)
+ {
+ error (0, errno, "Failed to link file: %s", dso->filename);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* Free memory and clear global variables. */
+static void
+cleanup (void)
+{
+ dw_cu_ref cu;
+ unsigned int i;
+
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ {
+ if (cu->cu_new_abbrev)
+ htab_delete (cu->cu_new_abbrev);
+ cu->cu_new_abbrev = NULL;
+ }
+ if (off_htab != NULL)
+ {
+ if (tracing)
+ htab_report (off_htab, "off_htab final");
+ htab_delete (off_htab);
+ }
+ off_htab = NULL;
+ if (types_off_htab != NULL)
+ htab_delete (types_off_htab);
+ types_off_htab = NULL;
+ if (loc_htab != NULL)
+ htab_delete (loc_htab);
+ loc_htab = NULL;
+ if (loclists_htab != NULL)
+ htab_delete (loclists_htab);
+ loclists_htab = NULL;
+ if (dup_htab != NULL)
+ htab_delete (dup_htab);
+ dup_htab = NULL;
+ if (strp_htab != NULL)
+ htab_delete (strp_htab);
+ strp_htab = NULL;
+ if (line_htab != NULL)
+ htab_delete (line_htab);
+ line_htab = NULL;
+ if (macro_htab != NULL)
+ htab_delete (macro_htab);
+ macro_htab = NULL;
+ if (meta_abbrev_htab != NULL)
+ htab_delete (meta_abbrev_htab);
+ meta_abbrev_htab = NULL;
+
+ for (i = 0; i < SAVED_SECTIONS; ++i)
+ {
+ free (saved_new_data[i]);
+ saved_new_data[i] = NULL;
+ }
+
+ obstack_free (&ob2, NULL);
+ obstack_free (&ob, NULL);
+ memset (&ob2, '\0', sizeof (ob2));
+ memset (&ob, '\0', sizeof (ob2));
+ die_nontoplevel_freelist = NULL;
+ die_collapsed_child_freelist = NULL;
+ pool_destroy (NULL);
+ first_cu = NULL;
+ last_cu = NULL;
+ ptr_size = 0;
+ max_nattr = 0;
+ do_read_16 = NULL;
+ do_read_32 = NULL;
+ do_read_64 = NULL;
+ do_write_16 = NULL;
+ do_write_32 = NULL;
+ do_write_64 = NULL;
+ edge_freelist = NULL;
+ multifile_mode = 0;
+ max_strp_off = 0;
+ max_line_id = 0;
+}
+
+/* Propagate the die_no_multifile property along the duplicate chain of which
+ DIE is a member. If the property was changed on any die, set *CHANGED to
+ true. */
+static void
+propagate_multifile_duplicate_chain (dw_die_ref die, bool *changed)
+{
+ dw_die_ref dup = first_dup (die);
+ if (!dup)
+ return;
+
+ while (dup && dup->die_offset == -1U)
+ dup = dup->die_nextdup;
+ if (dup != die)
+ return;
+
+ bool any_no_multifile = false;
+ bool any_multifile = false;
+ bool prop_needed = false;
+ dw_die_ref d;
+ for (d = dup; d && !prop_needed; d = d->die_nextdup)
+ {
+ if (d->die_no_multifile)
+ any_no_multifile = true;
+ else
+ any_multifile = true;
+ prop_needed = any_no_multifile && any_multifile;
+ }
+ if (!prop_needed)
+ return;
+
+ *changed = true;
+
+ for (d = dup; d; d = d->die_nextdup)
+ d->die_no_multifile = 1;
+}
+
+/* Propagate the die_no_multifile property backwards along the outgoing
+ references of DIE, which is a member of CU and of the subtree of lower
+ toplevel die TOP_DIE. If the property was changed on any die, set *CHANGED
+ to true. */
+static void
+propagate_multifile_refs_backward (dw_cu_ref cu, dw_die_ref top_die,
+ dw_die_ref die, bool *changed)
+{
+ struct abbrev_tag *t = die->die_abbrev;
+ unsigned int i;
+ unsigned char *ptr;
+ dw_die_ref child;
+
+ if (die->die_offset == -1U)
+ return;
+
+ ptr = debug_sections[DEBUG_INFO].data + die->die_offset;
+ skip_leb128 (ptr);
+ for (i = 0; i < t->nattr; ++i)
+ {
+ uint32_t form = t->attr[i].form;
+ uint64_t value;
+ dw_die_ref ref, reft;
+
+ while (form == DW_FORM_indirect)
+ form = read_uleb128 (ptr);
+
+ switch (form)
+ {
+ case DW_FORM_ref_addr:
+ value = read_size (ptr, cu->cu_version == 2 ? ptr_size : 4);
+ ptr += cu->cu_version == 2 ? ptr_size : 4;
+ ref = off_htab_lookup (cu, value);
+ goto finish_ref;
+ break;
+ case DW_FORM_ref_udata:
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ case DW_FORM_ref8:
+ switch (form)
+ {
+ case DW_FORM_ref_udata: value = read_uleb128 (ptr); break;
+ case DW_FORM_ref1: value = read_8 (ptr); break;
+ case DW_FORM_ref2: value = read_16 (ptr); break;
+ case DW_FORM_ref4: value = read_32 (ptr); break;
+ case DW_FORM_ref8: value = read_64 (ptr); break;
+ default: abort ();
+ }
+ if (t->attr[i].attr == DW_AT_sibling)
+ break;
+ ref = off_htab_lookup (cu, cu->cu_offset + value);
+ finish_ref:
+ reft = ref;
+ while (!reft->die_root
+ && reft->die_parent->die_tag != DW_TAG_compile_unit
+ && reft->die_parent->die_tag != DW_TAG_partial_unit
+ && !reft->die_parent->die_named_namespace)
+ reft = reft->die_parent;
+ if (reft->die_root)
+ ;
+ else if (reft->die_ck_state == CK_KNOWN
+ && !top_die->die_no_multifile && reft->die_no_multifile)
+ {
+ top_die->die_no_multifile = 1;
+ *changed = true;
+ }
+ break;
+ default:
+ ptr = skip_attr_no_dw_form_indirect (cu->cu_version, form, ptr);
+ }
+ }
+
+ for (child = die->die_child; child; child = child->die_sib)
+ propagate_multifile_refs_backward (cu, top_die, child, changed);
+}
+
+/* Do propagation of the die_no_multifile property that was not covered in
+ checksum_die and checksum_ref_die. */
+static void
+propagate_multifile (void)
+{
+ bool changed;
+ dw_cu_ref cu;
+ dw_die_ref die;
+
+ changed = false;
+
+ FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+ propagate_multifile_duplicate_chain (die, &changed);
+
+ if (!changed)
+ return;
+
+ do
+ {
+ changed = false;
+
+ FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+ propagate_multifile_refs_backward (cu, die, die, &changed);
+
+ FOREACH_CU_NORMAL_LOW_TOPLEVEL_DIE (cu, die)
+ propagate_multifile_duplicate_chain (die, &changed);
+ }
+ while (changed);
+}
+
+/* Returns true if DIE contains any toplevel children that can be
+ potentially shared between different executables or shared libraries. */
+static bool
+check_multifile (dw_die_ref die)
+{
+ dw_die_ref child;
+
+ die->die_no_multifile = 1;
+ for (child = die->die_child; child; child = child->die_sib)
+ if (child->die_named_namespace)
+ {
+ if (check_multifile (child))
+ die->die_no_multifile = 0;
+ }
+ else if (child->die_offset == -1U)
+ {
+ if (child->die_nextdup && child->die_nextdup->die_dup == child)
+ {
+ if (child->die_nextdup->die_ck_state == CK_KNOWN
+ && child->die_nextdup->die_no_multifile == 0)
+ {
+ child->die_no_multifile = 0;
+ die->die_no_multifile = 0;
+ }
+ else
+ child->die_no_multifile = 1;
+ }
+ else
+ child->die_no_multifile = 1;
+ }
+ else
+ {
+ child->die_op_type_referenced = 0;
+ if (child->die_dup == NULL
+ && child->die_ck_state == CK_KNOWN
+ && child->die_no_multifile == 0)
+ die->die_no_multifile = 0;
+ else
+ child->die_no_multifile = 1;
+ }
+ return die->die_no_multifile == 0;
+}
+
+/* Helper function for write_multifile_strp to sort strp_entry
+ by increasing new_off. */
+static int
+strp_off_cmp (const void *p, const void *q)
+{
+ struct strp_entry *s1 = *(struct strp_entry **)p;
+ struct strp_entry *s2 = *(struct strp_entry **)q;
+ if (s1->new_off < s2->new_off)
+ return -1;
+ if (s1->new_off > s2->new_off)
+ return 1;
+ return 0;
+}
+
+/* Write tail optimized strings into the temporary .debug_str file. */
+static int
+write_multifile_strp (void)
+{
+ unsigned int count = htab_elements (strp_htab), i, buf_alloc, buf_size;
+ struct strp_entry **arr = (struct strp_entry **)
+ obstack_alloc (&ob, count * sizeof (*arr));
+ struct strp_entry **end = arr;
+ unsigned char *buf;
+ int ret = 0;
+
+ htab_traverse (strp_htab, list_strp_entries, (void *) &end);
+ assert (arr + count == end);
+ qsort (arr, count, sizeof (struct strp_entry *), strp_off_cmp);
+ buf_alloc = max_strp_off - debug_sections[DEBUG_STR].size;
+ if (buf_alloc > 131072)
+ buf_alloc = 131072;
+ buf = (unsigned char *) obstack_alloc (&ob, buf_alloc);
+ buf_size = 0;
+ for (i = 0; i < count; i++)
+ {
+ unsigned char *p = debug_sections[DEBUG_STR].data + arr[i]->off;
+ unsigned int len = strlen ((char *) p) + 1;
+ if (buf_alloc - buf_size < len)
+ {
+ if (buf_size
+ && write (multi_str_fd, buf, buf_size) != (ssize_t) buf_size)
+ {
+ ret = 1;
+ break;
+ }
+ buf_size = 0;
+ if (buf_alloc < len)
+ {
+ if (write (multi_str_fd, p, len) != (ssize_t) len)
+ {
+ ret = 1;
+ break;
+ }
+ continue;
+ }
+ }
+ memcpy (buf + buf_size, p, len);
+ buf_size += len;
+ }
+ if (buf_size
+ && ret == 0
+ && write (multi_str_fd, buf, buf_size) != (ssize_t) buf_size)
+ ret = 1;
+ obstack_free (&ob, (void *) arr);
+ return ret;
+}
+
+/* Hold some statistics on the line entries so we know whether to emit
+ time and/or sizes. Used by list_line_entries used by
+ write_multifile_line. */
+struct line_stats
+{
+ struct line_entry ***end;
+ bool has_time;
+ bool has_size;
+};
+
+/* Helper to find the end of the line_htab entries and other stats.
+ Called through htab_traverse. */
+static int
+list_line_entries (void **slot, void *data)
+{
+ struct line_stats *stats = (struct line_stats *) data;
+ struct line_entry *entry = (struct line_entry *) *slot;
+ struct line_entry ***end = stats->end;
+ **end = entry;
+ (*end)++;
+ if (entry->file->time != 0)
+ stats->has_time = true;
+ if (entry->file->size != 0)
+ stats->has_size = true;
+ return 1;
+}
+
+/* Helper function for write_multifile_strp to sort line_entry
+ by increasing new_id. */
+static int
+line_id_cmp (const void *p, const void *q)
+{
+ struct line_entry *s1 = *(struct line_entry **)p;
+ struct line_entry *s2 = *(struct line_entry **)q;
+ if (s1->new_id < s2->new_id)
+ return -1;
+ if (s1->new_id > s2->new_id)
+ return 1;
+ return 0;
+}
+
+/* Write a minimal .debug_line entry. If not op_multifile, write it
+ into the temporary .debug_line file (if line_htab is non-NULL, fill
+ its directory and file table from it, otherwise emit an entry
+ with no directories or files), if op_multifile, store the entry
+ into debug_sections[DEBUG_LINE].new_data which it allocates. */
+static int
+write_multifile_line (void)
+{
+ unsigned int filecnt = 0, dircnt = 0, filetbllen = 0, dirtbllen = 0;
+ unsigned int header_len, len, i, j;
+ unsigned char *line, *ptr;
+ struct line_entry **filearr = NULL;
+ struct line_stats line_stats;
+ unsigned int *diridx = NULL, *dirarr = NULL;
+ unsigned char buf[45]; /* Max header_len, see below. */
+ int ret = 0;
+
+ line_stats.has_time = line_stats.has_size = false;
+ if (line_htab)
+ {
+ struct line_entry **end;
+ filecnt = htab_elements (line_htab);
+ filearr = (struct line_entry **)
+ obstack_alloc (&ob, filecnt * sizeof (*filearr));
+ end = filearr;
+ line_stats.end = &end;
+ htab_traverse (line_htab, list_line_entries, (void *) &line_stats);
+ assert (filearr + filecnt == end);
+ diridx = (unsigned int *)
+ obstack_alloc (&ob, filecnt * sizeof (*diridx));
+ qsort (filearr, filecnt, sizeof (struct line_entry *), line_id_cmp);
+ for (i = 0; i < filecnt; i++)
+ {
+ unsigned int direntrylen = 0;
+ const char *file = filearr[i]->file->file;
+ if (filearr[i]->file->dir == NULL)
+ {
+ const char *r = strrchr (file, '/'), *s;
+
+ j = 0;
+ direntrylen = r ? r - file : 0;
+ while (direntrylen && file[direntrylen - 1] == '/')
+ direntrylen--;
+ if (direntrylen)
+ {
+ direntrylen++;
+ for (j = 0; j < dircnt; j++)
+ if (filearr[dirarr[j]]->file->dir == NULL
+ && strncmp (filearr[dirarr[j]]->file->file,
+ file, direntrylen) == 0)
+ {
+ s = filearr[dirarr[j]]->file->file + direntrylen;
+ while (*s == '/')
+ s++;
+ if (strchr (s, '/'))
+ continue;
+ break;
+ }
+ j++;
+ file = r + 1;
+ }
+ }
+ else
+ {
+ for (j = 0; j < dircnt; j++)
+ if (filearr[dirarr[j]]->file->dir
+ && strcmp (filearr[dirarr[j]]->file->dir,
+ filearr[i]->file->dir) == 0)
+ break;
+ j++;
+ direntrylen = strlen (filearr[i]->file->dir) + 1;
+ }
+ if (j <= dircnt)
+ diridx[i] = j;
+ else
+ {
+ obstack_int_grow (&ob, i);
+ diridx[i] = ++dircnt;
+ dirarr = (unsigned int *) obstack_base (&ob);
+ dirtbllen += direntrylen;
+ }
+ filetbllen += strlen (file) + 1;
+ filetbllen += size_of_uleb128 (diridx[i]);
+ if (lowest_line_version < 5 || line_stats.has_time)
+ filetbllen += size_of_uleb128 (filearr[i]->file->time);
+ if (lowest_line_version < 5 || line_stats.has_size)
+ filetbllen += size_of_uleb128 (filearr[i]->file->size);
+ }
+ dirarr = (unsigned int *) obstack_finish (&ob);
+ }
+
+ /* standard .debug_line "header" length (both version 2 and 5):
+ unit_length (4) + version (2) + header_length (4) +
+ min_instr_length (1) + default_is_stmt (1) + line_base (1) +
+ line_range (1) + opcode_base (1) = 15
+
+ version 2 adds 2 bytes, one zero byte to terminate dir and file lists.
+
+ version 5 adds at least 11 bytes, max_ops_per_instr (1) +
+ address_size (1) + segment_size (1) + dir_entry_format_cnt (1) +
+ format_pair (2), file_entry_format_cnt (1) + file_format_pairs
+ (4). Plus dircnt (uleb128) + format_pair (2) if has_time +
+ format_pair (2) if has_size) + filecnt (uleb128).
+
+ version 5 also has 2 extra 6 byte "<dwz>" string entries for dir
+ and file entry zero, plus one for the zero file entry dir idx.
+ */
+ header_len = 15;
+ if (lowest_line_version < 5)
+ header_len += 2;
+ else
+ {
+ header_len += 11;
+ header_len += size_of_uleb128 (dircnt + 1);
+ header_len += size_of_uleb128 (filecnt + 1);
+ if (line_stats.has_time)
+ header_len += 2;
+ if (line_stats.has_size)
+ header_len += 2;
+ header_len += 2 * 6 + 1;
+ }
+ len = header_len + filetbllen + dirtbllen;
+ if (unlikely (op_multifile))
+ {
+ debug_sections[DEBUG_LINE].new_size = len;
+ debug_sections[DEBUG_LINE].new_data = malloc (len);
+ if (debug_sections[DEBUG_LINE].new_data == NULL)
+ dwz_oom ();
+ line = debug_sections[DEBUG_LINE].new_data;
+ }
+ else
+ {
+ if (multi_line_off + len < multi_line_off)
+ {
+ if (line_htab)
+ obstack_free (&ob, (void *) filearr);
+ return 1;
+ }
+
+ if (len == header_len)
+ {
+ line = buf;
+ assert (sizeof (buf) >= header_len);
+ }
+ else
+ line = (unsigned char *) obstack_alloc (&ob, len);
+ }
+ ptr = line;
+ write_32 (ptr, len - 4); /* Total length. */
+ if (lowest_line_version < 5)
+ write_16 (ptr, 2); /* DWARF version. */
+ else
+ {
+ write_16 (ptr, 5); /* DWARF version. */
+ write_8 (ptr, multi_ptr_size); /* Address size. */
+ write_8 (ptr, 0); /* Segment size. */
+ }
+ write_32 (ptr, /* Header length. */
+ len - (lowest_line_version < 5 ? 10 : 12));
+ write_8 (ptr, 1); /* Minimum insn length. */
+ if (lowest_line_version >= 5)
+ write_8 (ptr, 1); /* Maximum ops per instr. */
+ write_8 (ptr, 1); /* Default is_stmt. */
+ write_8 (ptr, 0); /* Line base. */
+ write_8 (ptr, 1); /* Line range. */
+ write_8 (ptr, 1); /* Opcode base. */
+
+ if (lowest_line_version >= 5)
+ {
+ write_8 (ptr, 1); /* Dir entry format count. */
+ write_uleb128 (ptr, DW_LNCT_path);
+ write_uleb128 (ptr, DW_FORM_string);
+ write_uleb128 (ptr, dircnt + 1); /* Dir cnt. */
+ memcpy (ptr, "<dwz>", 6); /* Zero entry empty dir path. */
+ ptr += 6;
+ }
+
+ for (i = 0; i < dircnt; i++)
+ {
+ unsigned int l;
+ if (filearr[dirarr[i]]->file->dir)
+ {
+ l = strlen (filearr[dirarr[i]]->file->dir) + 1;
+ memcpy (ptr, filearr[dirarr[i]]->file->dir, l);
+ }
+ else
+ {
+ const char *file = filearr[dirarr[i]]->file->file;
+ const char *r = strrchr (file, '/');
+
+ while (r && r > file && r[-1] == '/')
+ r--;
+ l = r - file + 1;
+ memcpy (ptr, file, l - 1);
+ ptr[l - 1] = '\0';
+ }
+ ptr += l;
+ }
+ if (lowest_line_version < 5)
+ write_8 (ptr, 0); /* Terminate dir table. */
+ else
+ {
+ unsigned int format_cnt = 2 + line_stats.has_size + line_stats.has_time;
+ write_8 (ptr, format_cnt); /* File entry format count. */
+ write_uleb128 (ptr, DW_LNCT_path);
+ write_uleb128 (ptr, DW_FORM_string);
+ write_uleb128 (ptr, DW_LNCT_directory_index);
+ write_uleb128 (ptr, DW_FORM_udata);
+ if (line_stats.has_time)
+ {
+ write_uleb128 (ptr, DW_LNCT_timestamp);
+ write_uleb128 (ptr, DW_FORM_udata);
+ }
+ if (line_stats.has_size)
+ {
+ write_uleb128 (ptr, DW_LNCT_size);
+ write_uleb128 (ptr, DW_FORM_udata);
+ }
+ write_uleb128 (ptr, filecnt + 1); /* File names cnt. */
+ memcpy (ptr, "<dwz>", 6); /* Zero entry empty file path. */
+ ptr += 6;
+ write_8 (ptr, 0); /* Zero entry zero diridx. */
+ if (line_stats.has_time)
+ write_8 (ptr, 0);
+ if (line_stats.has_size)
+ write_8 (ptr, 0);
+ }
+
+ for (i = 0; i < filecnt; i++)
+ {
+ const char *file = filearr[i]->file->file;
+ unsigned int l;
+ if (diridx[i] && filearr[i]->file->dir == NULL)
+ file = strrchr (file, '/') + 1;
+ l = strlen (file) + 1;
+ memcpy (ptr, file, l);
+ ptr += l;
+ write_uleb128 (ptr, diridx[i]);
+ if (lowest_line_version < 5 || line_stats.has_time)
+ write_uleb128 (ptr, filearr[i]->file->time);
+ if (lowest_line_version < 5 || line_stats.has_size)
+ write_uleb128 (ptr, filearr[i]->file->size);
+ }
+ if (lowest_line_version < 5)
+ write_8 (ptr, 0); /* Terminate file table. */
+ assert (ptr == line + len);
+
+ if (likely (!op_multifile))
+ {
+ if (write (multi_line_fd, line, len) != (ssize_t) len)
+ ret = 1;
+ else
+ multi_line_off += len;
+ if (line_htab)
+ obstack_free (&ob, (void *) filearr);
+ else if (line != buf)
+ obstack_free (&ob, (void *) line);
+ }
+ else if (line_htab)
+ obstack_free (&ob, (void *) filearr);
+ return ret;
+}
+
+#if DEVEL
+/* In struct dw_die we have a union u with fields p1 and p2. The p1 field is
+ used during phase 1, after which the space is reused for the p2 field
+ during phase 2. Clear the p2 field to get rid of values stored to p1
+ during phase 1. */
+static int
+clear_p2_field (void)
+{
+ dw_cu_ref cu;
+ dw_die_ref die;
+
+ FOREACH_DIE (cu, die)
+ {
+ assert (die->die_collapsed_child == 0);
+ die->u.p2.die_new_abbrev = NULL;
+ die->u.p2.die_new_offset = 0;
+ die->u.p2.die_intracu_udata_size = 0;
+ }
+
+ return 0;
+}
+#endif
+
+/* Helper structure for file state. */
+struct file_result
+{
+ /* -3: Uninitialized.
+ -2: Already processed under different name.
+ -1: Ignore.
+ 0: Processed, changed.
+ 1: Processed, unchanged. */
+ int res;
+ int ret;
+ size_t hardlink_to;
+ unsigned int die_count;
+ bool skip_multifile;
+ bool low_mem_p;
+};
+
+/* Collect potentially shareable DIEs, strings and .debug_macro
+ opcode sequences into temporary .debug_* files. */
+static int
+write_multifile_1 (DSO *dso, struct file_result *res)
+{
+ dw_cu_ref cu;
+ bool any_cus = false;
+ unsigned int i;
+ int ret = 0;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_multifile\n");
+ }
+
+ if (multi_ehdr.e_ident[0] == '\0')
+ multi_ehdr = dso->ehdr;
+
+ if (multifile_force_ptr_size && ptr_size != multifile_force_ptr_size)
+ {
+ error (0, 0, "File %s skipped for multi-file optimization, different"
+ " pointer size", dso->filename);
+ res->skip_multifile = true;
+ return 1;
+ }
+ else if (multi_ptr_size == 0)
+ multi_ptr_size = ptr_size;
+ else if (ptr_size != multi_ptr_size)
+ {
+ error (0, 0, "Multi-file optimization not allowed for different"
+ " pointer sizes");
+ multifile = NULL;
+ return 1;
+ }
+ else
+ {
+ /* Same ptr_size. */
+ }
+
+ int endianity = (do_read_32 == buf_read_ule32
+ ? ELFDATA2LSB
+ : ELFDATA2MSB);
+ if (multifile_force_endian && endianity != multifile_force_endian)
+ {
+ error (0, 0, "File %s skipped for multi-file optimization, different"
+ " endianity", dso->filename);
+ res->skip_multifile = true;
+ return 1;
+ }
+ else if (multi_endian == 0)
+ multi_endian = endianity;
+ else if (multi_endian != endianity)
+ {
+ error (0, 0, "Multi-file optimization not allowed for different"
+ " endianity");
+ multifile = NULL;
+ return 1;
+ }
+ else
+ {
+ /* Same endianity. */
+ }
+
+#if DEVEL
+ clear_p2_field ();
+#endif
+
+ for (i = 0; i < SAVED_SECTIONS; i++)
+ {
+ saved_new_data[i] = debug_sections[i].new_data;
+ saved_new_size[i] = debug_sections[i].new_size;
+ debug_sections[i].new_data = NULL;
+ debug_sections[i].new_size = debug_sections[i].size;
+ }
+ propagate_multifile ();
+ for (cu = first_cu; cu && cu->cu_kind != CU_TYPES; cu = cu->cu_next)
+ {
+ cu->u1.cu_new_abbrev_owner = NULL;
+ cu->u2.cu_new_abbrev_offset = 0;
+ cu->cu_new_offset = 0;
+ any_cus |= check_multifile (cu->cu_die);
+ }
+ if (any_cus)
+ {
+ dw_cu_ref *cup;
+
+ for (cup = &first_cu; *cup && (*cup)->cu_kind != CU_TYPES; )
+ {
+ if ((*cup)->cu_new_abbrev)
+ htab_delete ((*cup)->cu_new_abbrev);
+
+ if ((*cup)->cu_die->die_no_multifile == 0)
+ cup = &(*cup)->cu_next;
+ else
+ *cup = (*cup)->cu_next;
+ }
+ *cup = NULL;
+ multifile_mode = MULTIFILE_MODE_WR;
+ if (tracing)
+ fprintf (stderr, "Write-multifile %s\n", dso->filename);
+ if (compute_abbrevs (NULL))
+ ret = 1;
+ else if (debug_sections[DEBUG_MACRO].data && read_macro (dso))
+ ret = 1;
+ else if ((unsigned int) (multi_info_off
+ + debug_sections[DEBUG_INFO].new_size)
+ < multi_info_off
+ || (unsigned int) (multi_abbrev_off
+ + debug_sections[DEBUG_ABBREV].new_size)
+ < multi_abbrev_off
+ || (unsigned int) (multi_str_off
+ + (max_strp_off ? max_strp_off
+ : debug_sections[DEBUG_ABBREV].size))
+ < multi_str_off
+ || (unsigned int) (multi_macro_off
+ + debug_sections[DEBUG_MACRO].new_size)
+ < multi_macro_off)
+ {
+ error (0, 0, "Multifile temporary files too large");
+ multifile = NULL;
+ ret = 1;
+ }
+ else
+ {
+ const char *mfile;
+ write_abbrev ();
+ write_info (NULL);
+ /* Any error in this is fatal for multifile handling of further
+ files. */
+ mfile = multifile;
+ multifile = NULL;
+ if (write (multi_abbrev_fd, debug_sections[DEBUG_ABBREV].new_data,
+ debug_sections[DEBUG_ABBREV].new_size)
+ != (ssize_t) debug_sections[DEBUG_ABBREV].new_size
+ || write (multi_info_fd, debug_sections[DEBUG_INFO].new_data,
+ debug_sections[DEBUG_INFO].new_size)
+ != (ssize_t) debug_sections[DEBUG_INFO].new_size
+ || write (multi_str_fd, debug_sections[DEBUG_STR].data,
+ debug_sections[DEBUG_STR].size)
+ != (ssize_t) debug_sections[DEBUG_STR].size
+ || (debug_sections[DEBUG_MACRO].new_data
+ && write (multi_macro_fd,
+ debug_sections[DEBUG_MACRO].new_data,
+ debug_sections[DEBUG_MACRO].new_size)
+ != (ssize_t) debug_sections[DEBUG_MACRO].new_size)
+ || (strp_htab != NULL && write_multifile_strp ())
+ || write_multifile_line ())
+ {
+ error (0, 0, "Error writing multi-file temporary files");
+ ret = 1;
+ }
+ else
+ {
+ multi_info_off += debug_sections[DEBUG_INFO].new_size;
+ multi_abbrev_off += debug_sections[DEBUG_ABBREV].new_size;
+ multi_str_off += max_strp_off ? max_strp_off
+ : debug_sections[DEBUG_STR].size;
+ multi_macro_off += debug_sections[DEBUG_MACRO].new_size;
+ multifile = mfile;
+ }
+ }
+ }
+ multifile_mode = 0;
+ for (i = 0; i < SAVED_SECTIONS; i++)
+ {
+ free (debug_sections[i].new_data);
+ debug_sections[i].new_data = saved_new_data[i];
+ debug_sections[i].new_size = saved_new_size[i];
+ saved_new_data[i] = NULL;
+ }
+ return ret;
+}
+
+struct pipe
+{
+ int readfd;
+ int writefd;
+};
+
+static bool write_multifile_parallel_p;
+static int child_id;
+static struct pipe *pipes;
+
+/* Get token. */
+static void
+get_token (void)
+{
+ int n = child_id;
+ int readfd = pipes[n].readfd;
+ int writefd = pipes[n].writefd;
+ close (writefd);
+ char buf;
+ read (readfd, &buf, 1);
+ close (readfd);
+}
+
+/* Pass token to child N. */
+static void
+pass_token (int n)
+{
+ int readfd = pipes[n].readfd;
+ int writefd = pipes[n].writefd;
+ close (readfd);
+ char buf = '\0';
+ write (writefd, &buf, 1);
+ close (writefd);
+}
+
+/* Wrapper around write_multifile_1 that ensures write_multifile_1 is called
+ in file order. */
+static int
+write_multifile (DSO *dso, struct file_result *res)
+{
+ int ret;
+
+ if (write_multifile_parallel_p)
+ {
+ get_token ();
+
+ multi_info_off = lseek (multi_info_fd, 0L, SEEK_END);
+ multi_abbrev_off = lseek (multi_abbrev_fd, 0L, SEEK_END);
+ multi_line_off = lseek (multi_line_fd, 0L, SEEK_END);
+ multi_str_off = lseek (multi_str_fd, 0L, SEEK_END);
+ multi_macro_off = lseek (multi_macro_fd, 0L, SEEK_END);
+ }
+
+ ret = write_multifile_1 (dso, res);
+
+ return ret;
+}
+
+/* During fi_multifile phase, see what DIEs in a partial unit
+ contain no children worth keeping where all real DIEs have
+ dups in the shared .debug_info section and what remains is
+ just the DW_TAG_partial_unit, a single DW_TAG_imported_unit
+ and perhaps some empty named namespaces. Then all the
+ references to that partial unit can be replaced by references
+ to the shared partial unit DW_TAG_import_unit has been importing. */
+static bool
+remove_empty_pu (dw_die_ref die)
+{
+ dw_die_ref child = die->die_child, dup = NULL;
+ if (!die->die_named_namespace)
+ {
+ if (die->die_tag != DW_TAG_partial_unit
+ || child == NULL
+ || child->die_tag != DW_TAG_imported_unit
+ || child->die_offset != -1U)
+ return false;
+ if (die->die_abbrev->nattr > 2)
+ return false;
+ if (die->die_abbrev->nattr
+ && die->die_abbrev->attr[0].attr != DW_AT_stmt_list)
+ return false;
+ if (die->die_abbrev->nattr == 2
+ && die->die_abbrev->attr[1].attr != DW_AT_comp_dir)
+ return false;
+ dup = child->die_nextdup;
+ child = child->die_sib;
+ }
+ else
+ {
+ if (die->die_abbrev->nattr > 2)
+ return false;
+ if (die->die_abbrev->nattr
+ && die->die_abbrev->attr[0].attr != DW_AT_name)
+ return false;
+ if (die->die_abbrev->nattr == 2
+ && die->die_abbrev->attr[1].attr != DW_AT_sibling)
+ return false;
+ }
+ for (; child; child = child->die_sib)
+ if (!child->die_named_namespace)
+ {
+ if (!child->die_remove)
+ /* Signal that DIE can't be removed, but
+ perhaps we could still remove_empty_pu
+ some named namespaces that are children of DIE. */
+ dup = die;
+ if (dup == NULL && die->die_named_namespace)
+ dup = child->die_dup->die_parent;
+ }
+ else if (!remove_empty_pu (child))
+ return false;
+ else if (dup == NULL && die->die_named_namespace)
+ dup = child->die_dup->die_parent;
+ if (dup == NULL || dup == die)
+ return false;
+ die->die_remove = 1;
+ assert (dup->die_tag == die->die_tag);
+ die->die_dup = dup;
+ return true;
+}
+
+/* Call remove_empty_pu on all partial units. */
+static int
+remove_empty_pus (void)
+{
+ dw_cu_ref cu;
+ for (cu = first_cu; cu; cu = cu->cu_next)
+ if (cu->cu_kind == CU_NORMAL
+ && cu->cu_die->die_tag == DW_TAG_partial_unit)
+ remove_empty_pu (cu->cu_die);
+ return 0;
+}
+
+/* Handle compression of a single file FILE. If OUTFILE is
+ non-NULL, the result will be stored into that file, otherwise
+ the result will be written into a temporary file that is renamed
+ over FILE. */
+static int
+dwz (const char *file, const char *outfile, struct file_result *res)
+{
+ DSO *dso;
+ int ret = 0, fd;
+ unsigned int i;
+ struct stat st;
+
+ if (res->res == -1)
+ return 1;
+
+ res->res = -1;
+ fd = open (file, O_RDONLY);
+ if (fd < 0)
+ {
+ error (0, errno, "Failed to open input file %s", file);
+ return 1;
+ }
+ if (fstat (fd, &st) < 0)
+ {
+ close (fd);
+ error (0, errno, "Failed to stat input file %s", file);
+ return 1;
+ }
+
+ res->res = 1;
+
+ if (tracing)
+ {
+ fprintf (stderr, "Compressing %s", file);
+ if (multifile_mode == 0)
+ ;
+ else if (low_mem)
+ fprintf (stderr, " in low-mem mode");
+ else if (fi_multifile)
+ fprintf (stderr, " in finalize-multifile mode");
+ else
+ abort ();
+ fprintf (stderr, "\n");
+ }
+
+ dso = fdopen_dso (fd, file);
+ if (dso == NULL)
+ return 1;
+
+ obstack_alloc_failed_handler = dwz_oom;
+ if (setjmp (oom_buf))
+ {
+ error (0, ENOMEM, "%s: Could not allocate memory", dso->filename);
+
+ cleanup ();
+ ret = 1;
+ }
+ else
+ {
+ obstack_init (&ob);
+ obstack_init (&ob2);
+
+ unsigned int *die_count = multifile ? &res->die_count : NULL;
+ ret = read_dwarf (dso, quiet && outfile == NULL, die_count);
+ if (ret)
+ cleanup ();
+ else if (partition_dups ()
+ || create_import_tree ()
+ || (unlikely (fi_multifile)
+ && (remove_empty_pus ()
+ || read_macro (dso)))
+ || read_debug_info (dso, DEBUG_TYPES, NULL)
+#if DEVEL
+ || clear_p2_field ()
+#endif
+ || compute_abbrevs (dso)
+ || (unlikely (fi_multifile) && (finalize_strp (false), 0)))
+ {
+ cleanup ();
+ ret = 1;
+ }
+ else if (!(ignore_size || force_p)
+ && ((debug_sections[DEBUG_INFO].new_size
+ + debug_sections[DEBUG_ABBREV].new_size
+ + debug_sections[DEBUG_STR].new_size
+ + debug_sections[DEBUG_MACRO].new_size
+ + debug_sections[DEBUG_TYPES].new_size)
+ >= (debug_sections[DEBUG_INFO].size
+ + debug_sections[DEBUG_ABBREV].size
+ + debug_sections[DEBUG_STR].size
+ + debug_sections[DEBUG_MACRO].size
+ + debug_sections[DEBUG_TYPES].size)))
+ {
+ if (!quiet || outfile != NULL)
+ error (0, 0, "%s: DWARF compression not beneficial "
+ "- old size %ld new size %ld", dso->filename,
+ (unsigned long) (debug_sections[DEBUG_INFO].size
+ + debug_sections[DEBUG_ABBREV].size
+ + debug_sections[DEBUG_STR].size
+ + debug_sections[DEBUG_MACRO].size
+ + debug_sections[DEBUG_TYPES].size),
+ (unsigned long) (debug_sections[DEBUG_INFO].new_size
+ + debug_sections[DEBUG_ABBREV].new_size
+ + debug_sections[DEBUG_STR].new_size
+ + debug_sections[DEBUG_MACRO].new_size
+ + debug_sections[DEBUG_TYPES].new_size));
+
+ if (multifile && !fi_multifile && !low_mem)
+ write_multifile (dso, res);
+
+ cleanup ();
+ if (outfile != NULL)
+ ret = 1;
+ }
+ else if (write_aranges (dso))
+ {
+ failure:
+ cleanup ();
+ ret = 1;
+ }
+ else
+ {
+ if (unlikely (fi_multifile))
+ {
+ size_t len;
+ const char *name = multifile_name;
+ enum debug_section_kind sec_kind;
+ unsigned char *ptr;
+ if (multifile_name == NULL)
+ {
+ if (!multifile_relative)
+ name = multifile;
+ else
+ {
+ char *p1 = realpath (file, NULL);
+ char *p2 = realpath (multifile, NULL);
+ char *p3, *p4, *p5, *p6;
+ unsigned int dotdot = 0;
+ if (p1 == NULL || p2 == NULL)
+ {
+ if (p1)
+ free (p1);
+ else if (p2)
+ free (p2);
+ error (0, 0, "Could not compute relative multifile "
+ "pathname from %s to %s",
+ file, multifile);
+ goto failure;
+ }
+ p3 = p1;
+ p4 = p2;
+ do
+ {
+ p5 = strchr (p3, '/');
+ p6 = strchr (p4, '/');
+ if (p5 == NULL
+ || p6 == NULL
+ || p5 - p3 != p6 - p4
+ || memcmp (p3, p4, p5 - p3) != 0)
+ break;
+ p3 = p5 + 1;
+ p4 = p6 + 1;
+ }
+ while (1);
+ while (p5 != NULL)
+ {
+ dotdot++;
+ p5 = strchr (p5 + 1, '/');
+ }
+ len = strlen (p4);
+ p3 = (char *) malloc (dotdot * 3 + len + 1);
+ if (p3 == NULL)
+ dwz_oom ();
+ p5 = p3;
+ while (dotdot)
+ {
+ memcpy (p5, "../", 3);
+ p5 += 3;
+ dotdot--;
+ }
+ memcpy (p5, p4, len + 1);
+ free (p1);
+ free (p2);
+ name = p3;
+ }
+ }
+ len = strlen (name) + 1;
+ sec_kind = dwarf_5 ? DEBUG_SUP : GNU_DEBUGALTLINK;
+ debug_sections[sec_kind].new_size
+ = len + 0x14 + (dwarf_5 ? 4 : 0);
+ debug_sections[sec_kind].new_data
+ = malloc (debug_sections[sec_kind].new_size);
+ if (debug_sections[sec_kind].new_data == NULL)
+ dwz_oom ();
+ ptr = debug_sections[sec_kind].new_data;
+ if (dwarf_5)
+ {
+ write_16 (ptr, 5);
+ write_8 (ptr, 0);
+ }
+ memcpy (ptr, name, len);
+ ptr += len;
+ if (dwarf_5)
+ write_uleb128 (ptr, 0x14);
+ memcpy (ptr, multifile_sha1, 0x14);
+ if (name != multifile_name && name != multifile)
+ free ((void *) name);
+ write_macro ();
+ }
+ write_abbrev ();
+ write_info (die_count);
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_loc\n");
+ }
+ write_loc ();
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_loclists\n");
+ }
+ write_loclists ();
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_types\n");
+ }
+ write_types ();
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "write_gdb_index\n");
+ }
+ write_gdb_index ();
+ /* These sections are optional and it is unclear
+ how to adjust them. Just remove them. */
+ debug_sections[DEBUG_PUBNAMES].new_data = NULL;
+ debug_sections[DEBUG_PUBNAMES].new_size = 0;
+ debug_sections[DEBUG_PUBTYPES].new_data = NULL;
+ debug_sections[DEBUG_PUBTYPES].new_size = 0;
+ debug_sections[DEBUG_GNU_PUBNAMES].new_data = NULL;
+ debug_sections[DEBUG_GNU_PUBNAMES].new_size = 0;
+ debug_sections[DEBUG_GNU_PUBTYPES].new_data = NULL;
+ debug_sections[DEBUG_GNU_PUBTYPES].new_size = 0;
+
+ if (multifile && !fi_multifile && !low_mem)
+ write_multifile (dso, res);
+
+ bool save_to_temp = save_temps && multifile && multifile_mode == 0;
+ cleanup ();
+
+ if (write_dso (dso, outfile, &st, save_to_temp))
+ ret = 1;
+ else
+ res->res = 0;
+
+ if (unlikely (progress_p))
+ report_progress ();
+ }
+ }
+
+ for (i = 0; debug_sections[i].name; ++i)
+ {
+ debug_sections[i].data = NULL;
+ debug_sections[i].size = 0;
+ free (debug_sections[i].new_data);
+ debug_sections[i].new_data = NULL;
+ debug_sections[i].new_size = 0;
+ debug_sections[i].sec = 0;
+ }
+
+ if (elf_end (dso->elf) < 0)
+ {
+ error (0, 0, "elf_end failed: %s", elf_errmsg (elf_errno ()));
+ ret = 1;
+ }
+ close (fd);
+
+ free (dso);
+ if (ret == 3)
+ {
+ ret = (outfile != NULL) ? 1 : 0;
+ res->res = -1;
+ }
+ return ret;
+}
+
+/* In order to free all malloced memory at the end of optimize_multifile,
+ communicate .debug_str tail optimized offset list from optimize_multifile
+ to read_multifile using an mmapped chunk of memory pointed by this
+ variable. */
+static unsigned int *strp_tail_off_list;
+
+/* Process temporary .debug_* files, see what can be beneficially shared
+ and write a new ET_REL file, containing the shared .debug_* sections. */
+static int
+optimize_multifile (unsigned int *die_count)
+{
+ DSO dsobuf, *dso;
+ int fd = -1;
+ volatile int vfd = -1;
+ unsigned int i;
+ Elf *elf = NULL;
+ Elf *volatile velf = NULL;
+ GElf_Shdr shdr;
+ Elf_Scn *scn;
+ Elf_Data *data;
+ char *e_ident;
+ static const char shstrtab_gnu[]
+ = "\0.shstrtab\0.note.gnu.build-id\0.gdb_index\0"
+ ".debug_info\0.debug_abbrev\0.debug_line\0.debug_str\0.debug_macro";
+ static const char shstrtab_dwarf5[]
+ = "\0.shstrtab\0.gdb_index\0"
+ ".debug_info\0.debug_abbrev\0.debug_line\0.debug_str\0.debug_macro\0"
+ ".debug_sup";
+ const char *const shstrtab = dwarf_5 ? shstrtab_dwarf5 : shstrtab_gnu;
+ const size_t shstrtab_len = (dwarf_5
+ ? sizeof shstrtab_dwarf5
+ : sizeof shstrtab_gnu);
+ const char *p;
+ unsigned char note[0x24], *np, *supp;
+ struct sha1_ctx ctx;
+
+ if (multi_ehdr.e_ident[0] == '\0'
+ || multi_ptr_size == 0
+ || multi_endian == 0)
+ return -1;
+
+ if (multi_line_off == 0)
+ {
+ init_endian (multi_endian);
+ if (write_multifile_line ())
+ {
+ error (0, 0, "Error writing multi-file temporary files");
+ return -1;
+ }
+ }
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "optimize_multifile\n");
+ }
+
+ debug_sections[DEBUG_INFO].size = multi_info_off;
+ debug_sections[DEBUG_INFO].data
+ = (multi_info_off
+ ? mmap (NULL, multi_info_off, PROT_READ, MAP_PRIVATE, multi_info_fd, 0)
+ : NULL);
+ debug_sections[DEBUG_ABBREV].size = multi_abbrev_off;
+ debug_sections[DEBUG_ABBREV].data
+ = (multi_abbrev_off
+ ? mmap (NULL, multi_abbrev_off, PROT_READ, MAP_PRIVATE,
+ multi_abbrev_fd, 0)
+ : NULL);
+ debug_sections[DEBUG_LINE].size = multi_line_off;
+ debug_sections[DEBUG_LINE].data
+ = mmap (NULL, multi_line_off, PROT_READ, MAP_PRIVATE, multi_line_fd, 0);
+ debug_sections[DEBUG_STR].size = multi_str_off;
+ debug_sections[DEBUG_STR].data
+ = multi_str_off
+ ? mmap (NULL, multi_str_off, PROT_READ, MAP_PRIVATE, multi_str_fd, 0)
+ : NULL;
+ debug_sections[DEBUG_MACRO].size = multi_macro_off;
+ debug_sections[DEBUG_MACRO].data
+ = multi_macro_off
+ ? mmap (NULL, multi_macro_off, PROT_READ, MAP_PRIVATE, multi_macro_fd, 0)
+ : NULL;
+ if (debug_sections[DEBUG_INFO].data == MAP_FAILED
+ || debug_sections[DEBUG_ABBREV].data == MAP_FAILED
+ || debug_sections[DEBUG_LINE].data == MAP_FAILED
+ || debug_sections[DEBUG_STR].data == MAP_FAILED
+ || debug_sections[DEBUG_MACRO].data == MAP_FAILED)
+ {
+ error (0, 0, "Error mmapping multi-file temporary files");
+ fail:
+ cleanup ();
+ if (velf)
+ elf_end (velf);
+ if (vfd != -1)
+ {
+ unlink (multifile);
+ close (vfd);
+ }
+ if (debug_sections[DEBUG_INFO].data != MAP_FAILED)
+ munmap (debug_sections[DEBUG_INFO].data,
+ debug_sections[DEBUG_INFO].size);
+ if (debug_sections[DEBUG_ABBREV].data != MAP_FAILED)
+ munmap (debug_sections[DEBUG_ABBREV].data,
+ debug_sections[DEBUG_ABBREV].size);
+ if (debug_sections[DEBUG_LINE].data != MAP_FAILED)
+ munmap (debug_sections[DEBUG_LINE].data,
+ debug_sections[DEBUG_LINE].size);
+ if (debug_sections[DEBUG_STR].data != MAP_FAILED
+ && debug_sections[DEBUG_STR].data != NULL)
+ munmap (debug_sections[DEBUG_STR].data,
+ debug_sections[DEBUG_STR].size);
+ if (debug_sections[DEBUG_MACRO].data != MAP_FAILED
+ && debug_sections[DEBUG_MACRO].data != NULL)
+ munmap (debug_sections[DEBUG_MACRO].data,
+ debug_sections[DEBUG_MACRO].size);
+ return -1;
+ }
+
+ init_endian (multi_endian);
+ ptr_size = multi_ptr_size;
+ memset (&dsobuf, '\0', sizeof (dsobuf));
+ dso = &dsobuf;
+ dso->filename = multifile;
+ if (tracing)
+ fprintf (stderr, "Optimize-multifile\n");
+ multifile_mode = MULTIFILE_MODE_OP;
+
+ obstack_alloc_failed_handler = dwz_oom;
+ if (unoptimized_multifile)
+ {
+ for (i = 0; i < SAVED_SECTIONS; i++)
+ {
+ debug_sections[i].new_data = debug_sections[i].data;
+ debug_sections[i].new_size = debug_sections[i].size;
+ }
+ }
+ else if (setjmp (oom_buf))
+ {
+ error (0, ENOMEM, "%s: Could not allocate memory", dso->filename);
+ goto fail;
+ }
+ else
+ {
+ dw_cu_ref *cup;
+ unsigned char *p, *q;
+ unsigned int strp_count;
+
+ obstack_init (&ob);
+ obstack_init (&ob2);
+
+ if (read_debug_info (dso, DEBUG_INFO, NULL)
+ || partition_dups ())
+ goto fail;
+
+#if DEVEL
+ clear_p2_field ();
+#endif
+
+ for (cup = &first_cu; *cup && (*cup)->cu_kind == CU_PU;
+ cup = &(*cup)->cu_next)
+ ;
+
+ *cup = NULL;
+
+ strp_count = debug_sections[DEBUG_STR].size / 64;
+ if (strp_count < 64)
+ strp_count = 64;
+ strp_htab = htab_try_create (strp_count,
+ strp_hash2, strp_eq2, NULL);
+ if (strp_htab == NULL)
+ dwz_oom ();
+
+ for (p = debug_sections[DEBUG_STR].data;
+ p < debug_sections[DEBUG_STR].data + debug_sections[DEBUG_STR].size;
+ p = q + 1)
+ {
+ void **slot;
+ struct strp_entry se;
+ hashval_t hash;
+
+ q = (unsigned char *) strchr ((char *) p, '\0');
+ hash = hash (p, q - p);
+ se.off = p - debug_sections[DEBUG_STR].data;
+ se.new_off = hash & ~1U;
+ slot = htab_find_slot_with_hash (strp_htab, &se, se.new_off, INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ if (*slot == NULL)
+ {
+ struct strp_entry *s = pool_alloc (strp_entry, sizeof (*s));
+ *s = se;
+ *slot = (void *) s;
+ }
+ else
+ ((struct strp_entry *) *slot)->new_off |= 1;
+ }
+
+ if (first_cu != NULL)
+ {
+ if (compute_abbrevs (dso))
+ goto fail;
+
+ strp_tail_off_list = finalize_strp (true);
+
+ write_abbrev ();
+ write_info (die_count);
+ write_gdb_index ();
+ if (write_multifile_line ())
+ goto fail;
+ }
+ else
+ strp_tail_off_list = finalize_strp (true);
+
+ if (debug_sections[DEBUG_MACRO].data)
+ handle_macro ();
+ }
+
+ np = note;
+ write_32 (np, sizeof ("GNU"));
+ write_32 (np, 0x14);
+ write_32 (np, NT_GNU_BUILD_ID);
+
+ supp = NULL;
+ if (dwarf_5)
+ {
+ debug_sections[DEBUG_SUP].new_size = 0x14 + 5;
+ debug_sections[DEBUG_SUP].new_data
+ = malloc (debug_sections[DEBUG_SUP].new_size);
+ if (debug_sections[DEBUG_SUP].new_data == NULL)
+ dwz_oom ();
+ supp = debug_sections[DEBUG_SUP].new_data;
+ write_16 (supp, 5);
+ write_8 (supp, 1);
+ write_8 (supp, 0);
+ write_uleb128 (supp, 0x14);
+ }
+
+ cleanup ();
+ fd = open (multifile, O_RDWR | O_CREAT, 0600);
+ vfd = fd;
+ if (fd < 0)
+ {
+ error (0, errno, "Failed to open multi-file common file %s", multifile);
+ goto fail;
+ }
+
+ elf = elf_begin (fd, ELF_C_WRITE, NULL);
+ velf = elf;
+ if (elf == NULL)
+ {
+ error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1));
+ goto fail;
+ }
+
+ multi_ehdr.e_type = ET_REL;
+ multi_ehdr.e_entry = 0;
+ multi_ehdr.e_phoff = 0;
+ multi_ehdr.e_phnum = 0;
+ multi_ehdr.e_shoff = multi_ehdr.e_ehsize;
+ multi_ehdr.e_shnum = 2;
+ if (!dwarf_5)
+ {
+ multi_ehdr.e_shoff += 0x24;
+ multi_ehdr.e_shnum++;
+ }
+ for (i = 0; debug_sections[i].name; i++)
+ if (debug_sections[i].new_size)
+ {
+ multi_ehdr.e_shoff += debug_sections[i].new_size;
+ multi_ehdr.e_shnum++;
+ }
+ multi_ehdr.e_shstrndx = multi_ehdr.e_shnum - 1;
+
+ /* Some gelf_newehdr implementations don't return the resulting
+ ElfNN_Ehdr, so we have to do it the hard way instead of:
+ e_ident = (char *) gelf_newehdr (elf, gelf_getclass (dso->elf)); */
+ switch (multi_ehdr.e_ident[EI_CLASS])
+ {
+ case ELFCLASS32:
+ e_ident = (char *) elf32_newehdr (elf);
+ multi_ehdr.e_shoff = (multi_ehdr.e_shoff + 3) & -4;
+ break;
+ case ELFCLASS64:
+ e_ident = (char *) elf64_newehdr (elf);
+ multi_ehdr.e_shoff = (multi_ehdr.e_shoff + 7) & -8;
+ break;
+ default:
+ e_ident = NULL;
+ break;
+ }
+
+ if (e_ident == NULL
+ /* This is here just for the gelfx wrapper, so that gelf_update_ehdr
+ already has the correct ELF class. */
+ || memcpy (e_ident, multi_ehdr.e_ident, EI_NIDENT) == NULL
+ || gelf_update_ehdr (elf, &multi_ehdr) == 0)
+ {
+ error (0, 0, "Could not create new ELF headers");
+ goto fail;
+ }
+ elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT | ELF_F_PERMISSIVE);
+
+ sha1_init_ctx (&ctx);
+ for (i = 0; debug_sections[i].name; i++)
+ {
+ if (debug_sections[i].new_size == 0)
+ continue;
+ sha1_process_bytes (debug_sections[i].new_data,
+ debug_sections[i].new_size, &ctx);
+ }
+ sha1_finish_ctx (&ctx, multifile_sha1);
+
+ memcpy (np, "GNU", sizeof ("GNU"));
+ memcpy (np + 4, multifile_sha1, 0x14);
+
+ if (dwarf_5)
+ memcpy (supp, multifile_sha1, 0x14);
+
+ memset (&shdr, '\0', sizeof (shdr));
+ shdr.sh_offset = multi_ehdr.e_ehsize;
+ if (!dwarf_5)
+ {
+ shdr.sh_type = SHT_NOTE;
+ shdr.sh_addralign = 4;
+ shdr.sh_size = 0x24;
+ scn = elf_newscn (elf);
+ elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+ shdr.sh_name = (strchr (shstrtab + 1, '\0') + 1) - shstrtab;
+ gelf_update_shdr (scn, &shdr);
+ data = elf_newdata (scn);
+ data->d_buf = (char *) note;
+ data->d_type = ELF_T_BYTE;
+ data->d_version = EV_CURRENT;
+ data->d_size = shdr.sh_size;
+ data->d_off = 0;
+ data->d_align = 1;
+ }
+
+ shdr.sh_type = SHT_PROGBITS;
+ shdr.sh_offset += shdr.sh_size;
+ shdr.sh_addralign = 1;
+ for (i = 0; debug_sections[i].name; i++)
+ {
+ if (debug_sections[i].new_size == 0)
+ continue;
+ scn = elf_newscn (elf);
+ elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+ for (p = shstrtab + 1; p < shstrtab + shstrtab_len;
+ p = strchr (p, '\0') + 1)
+ if (strcmp (p, debug_sections[i].name) == 0)
+ {
+ shdr.sh_name = p - shstrtab;
+ break;
+ }
+ shdr.sh_size = debug_sections[i].new_size;
+ if (i == DEBUG_STR)
+ {
+ shdr.sh_flags = SHF_MERGE | SHF_STRINGS;
+ shdr.sh_entsize = 1;
+ }
+ else
+ {
+ shdr.sh_flags = 0;
+ shdr.sh_entsize = 0;
+ }
+ gelf_update_shdr (scn, &shdr);
+ data = elf_newdata (scn);
+ data->d_buf = debug_sections[i].new_data;
+ data->d_type = ELF_T_BYTE;
+ data->d_version = EV_CURRENT;
+ data->d_size = shdr.sh_size;
+ data->d_off = 0;
+ data->d_align = 1;
+ shdr.sh_offset += shdr.sh_size;
+ }
+ scn = elf_newscn (elf);
+ elf_flagscn (scn, ELF_C_SET, ELF_F_DIRTY);
+ shdr.sh_name = 1;
+ shdr.sh_offset = multi_ehdr.e_shoff
+ + multi_ehdr.e_shnum * multi_ehdr.e_shentsize;
+ shdr.sh_size = shstrtab_len;
+ shdr.sh_type = SHT_STRTAB;
+ shdr.sh_flags = 0;
+ shdr.sh_entsize = 0;
+ gelf_update_shdr (scn, &shdr);
+ data = elf_newdata (scn);
+ data->d_buf = (char *) shstrtab;
+ data->d_type = ELF_T_BYTE;
+ data->d_version = EV_CURRENT;
+ data->d_size = shdr.sh_size;
+ data->d_off = 0;
+ data->d_align = 1;
+
+ if (elf_update (elf, ELF_C_WRITE_MMAP) == -1)
+ {
+ error (0, 0, "%s: elf_update failed", multifile);
+ goto fail;
+ }
+
+ if (elf_end (elf) < 0)
+ {
+ error (0, 0, "elf_end failed: %s", elf_errmsg (elf_errno ()));
+ goto fail;
+ }
+
+ fchmod (fd, 0644);
+
+ if (dwarf_5)
+ {
+ free (debug_sections[DEBUG_SUP].new_data);
+ debug_sections[DEBUG_SUP].new_data = NULL;
+ }
+ munmap (debug_sections[DEBUG_INFO].data, debug_sections[DEBUG_INFO].size);
+ munmap (debug_sections[DEBUG_ABBREV].data,
+ debug_sections[DEBUG_ABBREV].size);
+ munmap (debug_sections[DEBUG_LINE].data, debug_sections[DEBUG_LINE].size);
+ if (debug_sections[DEBUG_STR].data)
+ munmap (debug_sections[DEBUG_STR].data, debug_sections[DEBUG_STR].size);
+ if (debug_sections[DEBUG_MACRO].data)
+ munmap (debug_sections[DEBUG_MACRO].data,
+ debug_sections[DEBUG_MACRO].size);
+
+ for (i = 0; debug_sections[i].name; ++i)
+ {
+ debug_sections[i].data = NULL;
+ debug_sections[i].size = 0;
+ if (!unoptimized_multifile)
+ free (debug_sections[i].new_data);
+ debug_sections[i].new_data = NULL;
+ debug_sections[i].new_size = 0;
+ debug_sections[i].sec = 0;
+ }
+
+ return fd;
+}
+
+/* Parse the .debug_* sections from shared ET_REL file written
+ by optimize_multifile into data structures for fi_multifile
+ phase. */
+static DSO *
+read_multifile (int fd, unsigned int die_count)
+{
+ DSO *dso, *volatile ret;
+ unsigned int i;
+
+ if (unlikely (progress_p))
+ {
+ report_progress ();
+ fprintf (stderr, "read_multifile\n");
+ }
+
+ if (tracing)
+ fprintf (stderr, "Read-multifile\n");
+
+ multifile_mode = MULTIFILE_MODE_RD;
+ dso = fdopen_dso (fd, multifile);
+ if (dso == NULL)
+ {
+ multifile_mode = 0;
+ return NULL;
+ }
+
+ ret = dso;
+ obstack_alloc_failed_handler = dwz_oom;
+ if (setjmp (oom_buf))
+ {
+ error (0, ENOMEM, "%s: Could not allocate memory", dso->filename);
+
+ fail:
+ elf_end (dso->elf);
+ close (fd);
+ free (dso);
+ ret = NULL;
+ alt_off_htab = NULL;
+ }
+ else
+ {
+ obstack_init (&ob);
+ obstack_init (&ob2);
+
+ if (read_dwarf (dso, false, &die_count))
+ goto fail;
+
+ if (debug_sections[DEBUG_STR].size)
+ {
+ unsigned char *p, *q;
+ unsigned int strp_count = debug_sections[DEBUG_STR].size / 64;
+ void **slot;
+ unsigned int *pi;
+
+ if (strp_count < 100)
+ strp_count = 100;
+ strp_htab = htab_try_create (strp_count, strp_hash3, strp_eq3, NULL);
+ if (strp_htab == NULL)
+ dwz_oom ();
+ for (p = debug_sections[DEBUG_STR].data;
+ p < debug_sections[DEBUG_STR].data
+ + debug_sections[DEBUG_STR].size; p = q)
+ {
+ q = (unsigned char *) strchr ((char *) p, '\0') + 1;
+ slot = htab_find_slot_with_hash (strp_htab, p,
+ hash (p, q - p - 1), INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ assert (*slot == NULL);
+ *slot = (void *) p;
+ }
+ if (strp_tail_off_list)
+ {
+ for (pi = strp_tail_off_list; *pi; pi++)
+ {
+ p = debug_sections[DEBUG_STR].data + *pi;
+ q = (unsigned char *) strchr ((char *) p, '\0');
+ slot = htab_find_slot_with_hash (strp_htab, p,
+ hash (p, q - p), INSERT);
+ if (slot == NULL)
+ dwz_oom ();
+ assert (*slot == NULL);
+ *slot = (void *) p;
+ }
+ pi++;
+ munmap (strp_tail_off_list,
+ (char *) pi - (char *) strp_tail_off_list);
+ }
+ }
+
+ if (debug_sections[DEBUG_MACRO].data)
+ handle_macro ();
+
+ alt_strp_htab = strp_htab;
+ strp_htab = NULL;
+ alt_off_htab = off_htab;
+ off_htab = NULL;
+ alt_dup_htab = dup_htab;
+ dup_htab = NULL;
+ alt_macro_htab = macro_htab;
+ macro_htab = NULL;
+ alt_first_cu = first_cu;
+ alt_pool = finalize_pool ();
+ alt_ob = ob;
+ alt_ob2 = ob2;
+ memset (&ob, '\0', sizeof (ob));
+ memset (&ob2, '\0', sizeof (ob2));
+ for (i = 0; i < SAVED_SECTIONS; i++)
+ {
+ alt_data[i] = debug_sections[i].data;
+ alt_size[i] = debug_sections[i].size;
+ }
+ }
+
+ cleanup ();
+
+ for (i = 0; debug_sections[i].name; ++i)
+ {
+ debug_sections[i].data = NULL;
+ debug_sections[i].size = 0;
+ debug_sections[i].new_data = NULL;
+ debug_sections[i].new_size = 0;
+ debug_sections[i].sec = 0;
+ }
+
+ return ret;
+}
+
+/* Clear all die_nextdup fields among toplevel children
+ of DIE. */
+static void
+alt_clear_dups (dw_die_ref die)
+{
+ dw_die_ref child;
+ assert (die->die_dup == NULL);
+ die->die_nextdup = NULL;
+ for (child = die->die_child; child; child = child->die_sib)
+ {
+ assert (child->die_dup == NULL);
+ child->die_nextdup = NULL;
+ if (child->die_named_namespace)
+ alt_clear_dups (child);
+ }
+}
+
+/* Create a temporary file using NAME. Return the corresponding file
+ descriptor if successful, otherwise return -1. */
+static int
+make_temp_file (const char *name)
+{
+ const char *tmpdir = "/tmp/";
+ const char *template_suffix = ".XXXXXX";
+ int fd;
+ size_t buf_len, offset, name_len;
+ char *buf;
+
+ if (save_temps)
+ {
+ FILE *f = fopen (name, "w+");
+ if (f == NULL)
+ fd = -1;
+ else
+ fd = fileno (f);
+ return fd;
+ }
+
+ name_len = strlen (name);
+ buf_len = (strlen (tmpdir)
+ + name_len
+ + strlen (template_suffix)
+ + 1);
+ if (buf_len < name_len)
+ return -1;
+ buf = (char *)malloc (buf_len);
+ if (buf == NULL)
+ return -1;
+ offset = 0;
+
+ strcpy (&buf[offset], tmpdir);
+ offset += strlen (tmpdir);
+
+ strcpy (&buf[offset], name);
+ offset += name_len;
+
+ strcpy (&buf[offset], template_suffix);
+ offset += strlen (template_suffix);
+
+ assert (offset == buf_len - 1);
+ assert (buf[offset] == '\0');
+
+ fd = mkstemp (buf);
+ if (fd == -1)
+ goto done;
+
+ /* Unlink the filename, such that the file is disposed of once the file
+ descriptor is closed. */
+ unlink (buf);
+
+ done:
+ free (buf);
+ return fd;
+}
+
+/* As dwz, but retry with MULTIFILE_MODE_LOW_MEM if the low_mem_die_limit
+ is hit. */
+static int
+dwz_with_low_mem (const char *file, const char *outfile,
+ struct file_result *res)
+{
+ int ret;
+
+ res->low_mem_p = false;
+
+ ret = (low_mem_die_limit == 0
+ ? 2
+ : dwz (file, outfile, res));
+
+ if (ret == 2)
+ {
+ multifile_mode = MULTIFILE_MODE_LOW_MEM;
+ res->low_mem_p = true;
+
+ ret = dwz (file, outfile, res);
+ }
+
+ return ret;
+}
+
+/* Initialize struct file_result RES. */
+static void
+init_file_result (struct file_result *res)
+{
+ res->die_count = 0;
+ res->res = -3;
+ res->skip_multifile = false;
+ res->low_mem_p = false;
+}
+
+/* Dwarf-compress FILE. If OUTFILE, write to result to OUTFILE, otherwise
+ modify FILE. */
+static int
+dwz_one_file (const char *file, const char *outfile)
+{
+ struct file_result res;
+
+ if (stats_p)
+ init_stats (file);
+
+ init_file_result (&res);
+
+ return dwz_with_low_mem (file, outfile, &res);
+}
+
+/* Helper structure for hardlink discovery. */
+struct hl_stat
+{
+ dev_t dev;
+ ino_t ino;
+ nlink_t nlink;
+};
+
+/* Detect which FILES are hardlinks, and mark those in RESA. */
+static bool
+detect_hardlinks (int nr_files, char *files[], struct file_result *resa)
+{
+ bool found = false;
+ struct hl_stat hl_stat[nr_files];
+ int i;
+
+ /* Try to open all files. */
+ for (i = 0; i < nr_files; i++)
+ {
+ struct file_result *res = &resa[i];
+ int fd;
+ struct stat st;
+
+ const char *file = files[i];
+ res->res = -1;
+
+ fd = open (file, O_RDONLY);
+ if (fd < 0)
+ error (0, errno, "Failed to open input file %s", file);
+ else if (fstat (fd, &st) < 0)
+ error (0, errno, "Failed to stat input file %s", file);
+ else
+ {
+ res->res = 1;
+ hl_stat[i].dev = st.st_dev;
+ hl_stat[i].ino = st.st_ino;
+ hl_stat[i].nlink = st.st_nlink;
+ }
+
+ close (fd);
+ }
+
+ /* Detect hard links. */
+ for (i = 0; i < nr_files; i++)
+ {
+ struct file_result *res = &resa[i];
+ int n;
+ for (n = 0; n != i; n++)
+ if (resa[n].res >= 0
+ && hl_stat[n].nlink > 1
+ && hl_stat[n].dev == hl_stat[i].dev
+ && hl_stat[n].ino == hl_stat[i].ino)
+ break;
+ if (n == i)
+ continue;
+ res->res = -2;
+ res->hardlink_to = n;
+ found = true;
+ }
+
+ return found;
+}
+
+/* Update the FILES marked as hardlink in RESA. */
+static void
+update_hardlinks (int nr_files, char *files[], struct file_result *resa)
+{
+ int i;
+
+ /* Update hardlinks. */
+ for (i = 0; i < nr_files; i++)
+ {
+ struct file_result *res = &resa[i];
+ const char *file = files[i];
+ size_t n;
+ if (res->res != -2)
+ continue;
+ n = res->hardlink_to;
+
+ /* If a hardlink to this has been processed before
+ and we didn't change it, just assume the same
+ state. */
+ if (resa[n].res == 1)
+ {
+ if (tracing)
+ fprintf (stderr, "Skipping hardlink %s to unchanged file\n",
+ file);
+ continue;
+ }
+
+ /* If it changed, try to hardlink it again. */
+ if (resa[n].res == 0)
+ {
+ size_t len = strlen (file);
+ char *filename = alloca (len + sizeof (".#dwz#.XXXXXX"));
+ int fd2;
+ if (tracing)
+ fprintf (stderr, "Updating hardlink %s to changed file\n",
+ file);
+ memcpy (filename, file, len);
+ memcpy (filename + len, ".#dwz#.XXXXXX",
+ sizeof (".#dwz#.XXXXXX"));
+ fd2 = mkstemp (filename);
+ if (fd2 >= 0)
+ {
+ close (fd2);
+ unlink (filename);
+ if (link (files[n], filename) == 0)
+ {
+ if (rename (filename, file) == 0)
+ ;
+ else
+ unlink (filename);
+ }
+ }
+ }
+ }
+}
+
+/* Encode child process exit status. */
+static int
+encode_child_exit_status (int thisret, struct file_result *res)
+{
+ assert (thisret == 0 || thisret == 1);
+ if (thisret == 0 && res->low_mem_p)
+ thisret = 2;
+ assert (res->res >= -3 && res->res <= 1);
+ return (thisret
+ + ((res->res + 3) << 2)
+ + ((res->skip_multifile ? 1 : 0) << 5));
+}
+
+/* Decode child process exit status. */
+static int
+decode_child_exit_status (int state, struct file_result *res)
+{
+ int ret;
+ if (!WIFEXITED (state))
+ error (1, 0, "Child dwz process got killed");
+ int status = WEXITSTATUS (state);
+ ret = status & 0x3;
+ status >>= 2;
+
+ res->low_mem_p = false;
+ if (ret == 2)
+ {
+ ret = 0;
+ res->low_mem_p = true;
+ }
+
+ res->res = (int)(status & 0x7) - 3;
+ status >>= 3;
+
+ res->skip_multifile = (status & 0x1) ? true : false;
+
+ return ret;
+}
+
+/* Wait on child exit with PID, update PIDS and RES. */
+static void
+wait_child_exit (pid_t pid, pid_t *pids, int nr_pids,
+ struct file_result *resa)
+{
+ int state;
+ pid_t got_pid = waitpid (pid, &state, 0);
+
+ int i;
+ for (i = 0; i < nr_pids; ++i)
+ if (pids[i] == got_pid)
+ {
+ pids[i] = 0;
+ break;
+ }
+ assert (i < nr_pids);
+
+ resa[i].ret = decode_child_exit_status (state, &resa[i]);
+}
+
+static int *workset;
+static int workset_size = 0;
+int current_multifile_owner = -1;
+int current_multifile_owner_file_idx = -1;
+
+/* Wait on exit of chilren in PIDS, update RESA. */
+static void
+wait_children_exit (pid_t *pids, int nr_files, struct file_result *resa)
+{
+ int i;
+ for (i = 0; i < nr_files; i++)
+ {
+ struct file_result *res = &resa[i];
+ if (pids[i] == 0)
+ continue;
+ wait_child_exit (pids[i], &pids[i], 1, res);
+ if (current_multifile_owner_file_idx == -1
+ || i < current_multifile_owner_file_idx)
+ continue;
+ assert (i == current_multifile_owner_file_idx);
+ current_multifile_owner++;
+ if (current_multifile_owner == workset_size)
+ continue;
+ current_multifile_owner_file_idx
+ = workset[current_multifile_owner];
+ pass_token (current_multifile_owner);
+ }
+}
+
+/* Dwarf-compress FILES. If HARDLINK, detect if some files are hardlinks and
+ if so, dwarf-compress just one, and relink the others. */
+static int
+dwz_files_1 (int nr_files, char *files[], bool hardlink,
+ struct file_result *resa)
+{
+ int ret = 0;
+ int i, j;
+ const char *file;
+ int successcount = 0;
+
+ for (i = 0; i < nr_files; ++i)
+ init_file_result (&resa[i]);
+
+ if (multifile)
+ {
+ if (multifile_force_ptr_size)
+ multi_ptr_size = multifile_force_ptr_size;
+ if (multifile_force_endian)
+ multi_endian = multifile_force_endian;
+
+ multi_info_fd = make_temp_file ("dwz.debug_info");
+ multi_abbrev_fd = make_temp_file ("dwz.debug_abbrev");
+ multi_line_fd = make_temp_file ("dwz.debug_line");
+ multi_str_fd = make_temp_file ("dwz.debug_str");
+ multi_macro_fd = make_temp_file ("dwz.debug_macro");
+ if (multi_info_fd == -1
+ || multi_abbrev_fd == -1
+ || multi_line_fd == -1
+ || multi_str_fd == -1
+ || multi_macro_fd == -1)
+ {
+ error (0, 0, "Could not create multifile temporary files");
+ multifile = NULL;
+ }
+ }
+
+ if (hardlink)
+ hardlink = detect_hardlinks (nr_files, files, resa);
+
+ workset = malloc (nr_files * sizeof (int));
+ if (workset == NULL)
+ error (1, ENOMEM, "failed to allocate workset array");
+ for (i = 0; i < nr_files; i++)
+ {
+ struct file_result *res = &resa[i];
+ if (res->res == -2)
+ /* Skip hard links. */
+ continue;
+ workset[workset_size] = i;
+ workset_size++;
+ }
+
+ bool initial_parallel_p = max_forks > 1;
+ if (initial_parallel_p && multifile)
+ {
+ if (multifile_force_ptr_size != 0 && multifile_force_endian != 0)
+ {
+ write_multifile_parallel_p = true;
+ pipes = malloc (workset_size * 2 * sizeof (int));
+ if (pipes == NULL)
+ error (1, ENOMEM, "failed to allocate pipes array");
+ for (i = 0; i < workset_size; i++)
+ {
+ int fds[2];
+ if (pipe (fds) != 0)
+ error (1, ENOMEM, "failed to initialize pipe");
+ pipes[i].readfd = fds[0];
+ pipes[i].writefd = fds[1];
+ }
+ }
+ else
+ initial_parallel_p = false;
+ }
+ if (initial_parallel_p)
+ {
+ pid_t pids[nr_files];
+ int nr_forks = 0;
+ for (i = 0; i < nr_files; i++)
+ pids[i] = 0;
+ for (j = 0; j < workset_size; j++)
+ {
+ int i = workset[j];
+
+ if (nr_forks == max_forks)
+ {
+ if (multifile == NULL)
+ wait_child_exit (-1, pids, i, resa);
+ else
+ {
+ int k = current_multifile_owner_file_idx;
+ wait_child_exit (pids[k], &pids[k], 1, &resa[k]);
+ current_multifile_owner++;
+ current_multifile_owner_file_idx
+ = workset[current_multifile_owner];
+ pass_token (current_multifile_owner);
+ }
+ nr_forks--;
+ }
+
+ pid_t fork_res = fork ();
+ assert (fork_res != -1);
+ if (fork_res == 0)
+ {
+ child_id = j;
+ file = files[i];
+ struct file_result *res = &resa[i];
+ int thisret = dwz_with_low_mem (file, NULL, res);
+ return encode_child_exit_status (thisret, res);
+ }
+ else
+ {
+ if (multifile && j == 0)
+ {
+ current_multifile_owner = j;
+ current_multifile_owner_file_idx
+ = workset[current_multifile_owner];
+ pass_token (current_multifile_owner);
+ }
+ pids[i] = fork_res;
+ nr_forks++;
+ }
+ }
+ if (nr_forks > 0)
+ wait_children_exit (pids, nr_files, resa);
+ }
+ else
+ {
+ for (j = 0; j < workset_size; j++)
+ {
+ int i = workset[j];
+ file = files[i];
+ struct file_result *res = &resa[i];
+ if (stats_p)
+ init_stats (file);
+ res->ret = dwz_with_low_mem (file, NULL, res);
+ }
+ }
+
+ for (j = 0; j < workset_size; j++)
+ {
+ int i = workset[j];
+ struct file_result *res = &resa[i];
+ int thisret = res->ret;
+ if (thisret == 1)
+ ret = 1;
+ else if (!res->low_mem_p && !res->skip_multifile && res->res >= 0)
+ successcount++;
+ }
+
+ if (hardlink)
+ update_hardlinks (nr_files, files, resa);
+
+ if (multifile == NULL)
+ return ret;
+
+ if (successcount < 2)
+ {
+ error (0, 0, "Too few files for multifile optimization");
+ return ret;
+ }
+
+ if (write_multifile_parallel_p)
+ {
+ multi_info_off = lseek (multi_info_fd, 0L, SEEK_END);
+ multi_abbrev_off = lseek (multi_abbrev_fd, 0L, SEEK_END);
+ multi_line_off = lseek (multi_line_fd, 0L, SEEK_END);
+ multi_str_off = lseek (multi_str_fd, 0L, SEEK_END);
+ multi_macro_off = lseek (multi_macro_fd, 0L, SEEK_END);
+ }
+ if (multi_info_off == 0 && multi_str_off == 0 && multi_macro_off == 0)
+ {
+ if (!quiet)
+ error (0, 0, "No suitable DWARF found for multifile optimization");
+ return ret;
+ }
+
+ if (write_multifile_parallel_p)
+ {
+ /* We reproduce here what happens when we run sequentially. This is a
+ kludge that probably needs to be replaced by IPC. */
+ for (i = 0; i < nr_files; i++)
+ {
+ struct file_result *res = &resa[i];
+ if (!res->low_mem_p && !res->skip_multifile && res->res >= 0)
+ {
+ int fd = open (files[i], O_RDONLY);
+ if (fd < 0)
+ return ret;
+ DSO *dso = fdopen_dso (fd, files[i]);
+ if (dso == NULL)
+ {
+ close (fd);
+ return ret;
+ }
+ assert (multi_ehdr.e_ident[0] == '\0');
+ multi_ehdr = dso->ehdr;
+ break;
+ }
+ }
+ }
+
+ unsigned int multifile_die_count = 0;
+ int multi_fd = optimize_multifile (&multifile_die_count);
+ DSO *dso;
+ if (multi_fd == -1)
+ return 1;
+
+ dso = read_multifile (multi_fd, multifile_die_count);
+ if (dso == NULL)
+ {
+ ret = 1;
+ goto cleanup;
+ }
+
+ workset_size = 0;
+ for (i = 0; i < nr_files; i++)
+ {
+ struct file_result *res = &resa[i];
+ /* Don't process again files that couldn't
+ be processed successfully. Also skip hard links. */
+ if (res->res == -1 || res->res == -2
+ || res->skip_multifile)
+ continue;
+ workset[workset_size] = i;
+ workset_size++;
+ }
+
+ bool finalize_multifile_parallel_p = max_forks > 1;
+ if (finalize_multifile_parallel_p)
+ {
+ pid_t pids[nr_files];
+ int nr_forks = 0;
+ for (i = 0; i < nr_files; i++)
+ pids[i] = 0;
+ for (j = 0; j < workset_size; j++)
+ {
+ int i = workset[j];
+
+ if (nr_forks == max_forks)
+ {
+ wait_child_exit (-1, pids, i, resa);
+ nr_forks--;
+ }
+
+ pid_t fork_res = fork ();
+ assert (fork_res != -1);
+ if (fork_res == 0)
+ {
+ file = files[i];
+ struct file_result *res = &resa[i];
+ multifile_mode = MULTIFILE_MODE_FI;
+ int thisret = dwz (file, NULL, res);
+ return encode_child_exit_status (thisret, res);
+ }
+ else
+ {
+ pids[i] = fork_res;
+ nr_forks++;
+ }
+ }
+ if (nr_forks > 0)
+ wait_children_exit (pids, nr_files, resa);
+ }
+ else
+ {
+ for (j = 0; j < workset_size; j++)
+ {
+ int i = workset[j];
+ struct file_result *res = &resa[i];
+ dw_cu_ref cu;
+ file = files[i];
+ if (stats_p)
+ init_stats (file);
+ multifile_mode = MULTIFILE_MODE_FI;
+ for (cu = alt_first_cu; cu; cu = cu->cu_next)
+ alt_clear_dups (cu->cu_die);
+ res->ret = dwz (file, NULL, res);
+ }
+ }
+
+ for (j = 0; j < workset_size; j++)
+ {
+ int i = workset[j];
+ struct file_result *res = &resa[i];
+ int thisret = res->ret;
+ ret |= thisret;
+ }
+
+ if (hardlink)
+ update_hardlinks (nr_files, files, resa);
+
+ elf_end (dso->elf);
+ close (multi_fd);
+ free (dso);
+
+ cleanup:
+ cleanup ();
+
+ strp_htab = alt_strp_htab;
+ off_htab = alt_off_htab;
+ dup_htab = alt_dup_htab;
+ macro_htab = alt_macro_htab;
+ ob = alt_ob;
+ ob2 = alt_ob2;
+ cleanup ();
+ pool_destroy (alt_pool);
+
+ return ret;
+}
+
+/* Wrapper around dwz_files_1 that takes care of malloc and free of resa. */
+static int
+dwz_files (int nr_files, char *files[], bool hardlink)
+{
+ int ret;
+ struct file_result *resa
+ = (struct file_result *) malloc ((nr_files) * sizeof (*resa));
+ if (resa == NULL)
+ error (1, ENOMEM, "failed to allocate result array");
+
+ ret = dwz_files_1 (nr_files, files, hardlink, resa);
+
+ free (resa);
+ return ret;
+}
+
+int
+main (int argc, char *argv[])
+{
+ int ret;
+ const char *outfile;
+ bool hardlink;
+ int nr_files;
+ char **files;
+
+ state = XXH64_createState ();
+
+ if (elf_version (EV_CURRENT) == EV_NONE)
+ error (1, 0, "library out of date");
+
+ outfile = NULL;
+ hardlink = false;
+ parse_args (argc, argv, &hardlink, &outfile);
+ nr_files = argc - optind;
+ files = &argv[optind];
+
+ if (nr_files <= 1)
+ {
+ const char *file = nr_files == 0 ? "a.out" : files[0];
+
+ if (multifile != NULL)
+ {
+ error (0, 0, "Too few files for multifile optimization");
+ multifile = NULL;
+ }
+
+ ret = dwz_one_file (file, outfile);
+ }
+ else
+ {
+ if (outfile != NULL)
+ error (1, 0, "-o option not allowed for multiple files");
+
+ ret = dwz_files (nr_files, files, hardlink);
+ }
+
+ if (stats_p)
+ free (stats);
+
+ return ret;
+}