Compile with -D_FILE_OFFSET_BITS=64.

Fix size computation for DW_FORM_string DW_AT_comp_dir attribute on PUs.

Handle even dups (arguably producer bugs) even within a single CU.

During partition_dups_1 second_phase only include non-referenced
DIEs alongside with referenced ones if they can't reference
DIEs not moved into PUs.

Also compare arr[k]->die_cu now that all dups are processed at once
during partition_dups.

Always perform parent check in die_eq_1 for toplevel dies,
Remove unneeded inside{1,2} testing.

Backport rth's
2002-04-09  Richard Henderson  <rth@redhat.com>

* hashtab.c (higher_prime_number): Use 7 as minimum.
(find_empty_slot_for_expand): Don't compute hash2 unless needed.
(htab_find_slot_with_hash): Likewise.
change.

Fix test whether attributes extend beyond end of CU.

During partition_dups process all dups at once, looking for references
from everywhere.

Use ELF_C_WRITE instead of ELF_C_WRITE_MMAP for elf_begin, it is
faster and doesn't leak mmapped region.

Fix up handling of DW_FORM_ref_addr in write_die.

During partition_dups, force together with anything that is worthwhile
to put into PUs also any DIEs that are referenced by those (even indirectly),
and any DIEs that are dups and referenced by the same set of CUs.
This way PUs should no longer DW_FORM_ref_addr to CU DIEs, unless they
were using DW_FORM_ref_addr already before.

Small bugfixes and code cleanups.

Handle DW_AT_start_scope with DW_FORM_sec_offset like DW_AT_ranges
- avoid dup checking for DIEs containing it.

Adjust .debug_aranges section if present.

Put new_data and new_size info about debug sections directly into
debug_sections array, to simplify write_dso and not passing around
too many pointers and sizes.

Optimize DW_AT_high_pc DW_FORM_addr for DWARF4+ into constant
class form DW_AT_high_pc (which is the size of the entity rather than
address of the first byte after it).

.gdb_index support, for versions 4-6 try to update it, otherwise
remove it.

IMPORTANT: usage change, no works similarly to strip.
dwz file
will modify file in place (well, write to temporary, rename over),
dwz -o outfile file
will do what dwz file outfile did before.
dwz file1 file2 file3
will modify all the files in place,
dwz
will modify a.out in place,
dwz -o b.out
will modify a.out into b.out.

In addition to that this change revamps the OOM handling to just
not handle the single currently handled file, complain,
cleanup all memory and continue with the next file.

Second part of memory management cleanups.  For permanently
(well, for the duration of handling a single file) allocated objects
use a big pool allocator that doesn't unnecessarily align everything
to 16 bytes and allocates in ~ 16MB chunks rather than 4KB.
This decreases memory usage a little bit on large testcases and
speeds things a tiny bit up.
Also, avoid obstacks local to function, for memory allocation failures
if in the future we use longjmp those might not be freed.

Don't htab_delete cu->cu_new_abbrev if it is already NULL
(happens for some .debug_types CUs).

First pass at memory management cleanup.  Ensure (so far only for success)
that all memory is freed before exit.

Undo optimistic die_dup/die_nextdup linking on failures in reverse
order of their addition.

Ignore .debug_gdb_scripts sections.

Use just u.p1.die_ref_hash instead of u.p1.die_hash ^ u.p1.die_ref_hash
as hash in the dup_htab hash table.  die_ref_hash has die_hash iteratively
hashed in already, and on leaf DIEs is equal to die_hash, so the xor
resulted in 0 for all leaf DIEs.

Improve ref_hash computation in cycles - add the forgotten
addition of *second_idx, so it doesn't hash in always 0.

Optimize .debug_abbrev handling for .debug_types section.  If
adjacent .debug_types CUs have the same .debug_abbrev offsets, just
read it once and point the others to the abbrev table owner's CU.

Fix a thinko that causes
create_import_tree: Assertion `ipu2->idx >= npus + ncus' failed.
on some objects.

Revamp die_dup/die_nextdup for easier debugging.  Instead of
two separate structures where second one contains the first at the
beginning just put the die_dup/die_nextdup fields last in the
single structure and for !die_toplevel DIEs just allocate using
offsetof (struct dw_die, die_dup) size (so those two fields will be
garbage).

dwz-0.1 - first public release