Remove .debug_pubnames and/or .debug_pubtypes section, instead of
aborting compression when they are seen.

Add lots of comments.
Replace struct dw_cu * with a new dw_cu_ref typedef.

Switch to gcc's dwarf{2.def,2.h,names.c} triplet from older dwarf2.h.
Use get_DW_*_name to print form/attribute/op names where possible.

Add -M and -r options.

Handle properly with -m the case when all of .debug_str is moved into the
alternate file.

Fix up .gdb_index rewriting if .debug_types section is not present.

Fix up TU signature store for big-endian.

Fix up .gdb_index adjusting if .debug_types section is present.

Implement special low_mem mode, which roughly halves amount of
needed RAM at the expense of small slowdown on very large
inputs (more than -l COUNT DIEs).  Give up if input has more than
-L COUNT DIEs.

Handle ref->die_collapsed_child in mark_refs.

Handle the case where multi_line_off and/or multi_str_off is 0
at the start of optimize_multifile.

Free resa array.

Add -h option to handle hardlinks properly.  Don't process files with
-m again in the second pass if they failed in the first pass.

Wire -q also in getopt_long argument.

Compile with -D_FILE_OFFSET_BITS=64.

Add -q option to make it more quiet.

Save some more memory by removing die_cu fields from struct dw_die.
Instead, the compile_unit/partial_unit die is tagged with die_root
bit, and die_parent is then a struct dw_cu pointer rather than
die pointer (before it was NULL).  To find a cu for any die
a new die_cu inline has been added.

Use origin instead of die->die_nextdup in DW_TAG_imported_unit handling.

Don't segfault if fi_multifile create_import_tree doesn't find
anything worthwhile from alternate DIE set.

Fix size computation for DW_FORM_string DW_AT_comp_dir attribute on PUs.

Fix error handling during {rd,fi}_multifile.

Replace referenced children during collapsing with 16 (resp. 12) bytes
long die_collapsed_child to further save memory during optimize_multifile.

Save memory during optimize_multifile by collapsing non-referenced
children of toplevel dies and expanding them again if needed
for die_eq_1 (anything that gets expanded will be kept expanded
afterwards).

Assume that in GCC created .debug_types abbrev offsets only increase
(or are the same as in last section).

Add a hashtable for abbrev offsets to decrease amount of abbrev_tag
alloced memory and decrease number of read_abbrev calls if
abbrev offsets in CUs don't increase monotonically (common for
dwz adjusted/created CUs).

During multifile_optimize, remove from off_htab all DIEs that are
never referenced using DW_FORM_* attributes.

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

Don't make distinction between former PUs and former CUs, put length
7 CU markers just after each DSO/executable chunk of CUs.  For
non-op_multifile mode use cu_chunk as a CU counter rather than keeping
it at 0.

Fix up updating .debug_types in -m mode - put .debug_types
section into the SAVED_SECTIONS group.

Rewrite .debug_types sections.

Clear alt_off_htab on read_multifile failures.

Add .gnu_debugaltlink sections during fi_multifile phase.

Don't leak macro_htab hash tables.

Add support for rewriting .debug_macro sections.

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.

In note_strp_offset2 during optimize_multifile record even off == 0
uses.

Fix up get_AT and get_AT_string for fi_multifile.

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.

In partition_find_dups during optimize_multifile ignore DIEs that
have dups (due to compiler bugs) only within the same DSO or executable.

Free new_data in op_multfile, add some debugging code, whitespace cleanup.

finalize_strp during fi_multifile before checking section sizes.

Fix test whether attributes extend beyond end of CU.

Add .note.gnu.build-id section to the common file.

Further multifile optimization work.

Don't emit any DW_TAG_imported_unit DIEs into the temporary file.

- cache read_debug_line results to decrease memory usage
- put DIEs that won't be needed again into freelist, allocate from that
- clear die_op_type_referenced during wr_multifile
- use ELF_C_WRITE instead of ELC_C_WRITE_MMAP in elf_begin

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

Further work on multi-file support, build from the gathered
sections a common file with DIEs and strings worth sharing between
different object files.

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.

Further little steps towards multi-file optimization.

First step towards multifile DWARF optimizations.
While handling input files normally, this gathers interesting
data in temporary files for .debug_{info,abbrev,line,str} sections,
then right now skips optimization pass on the gathered sections
and writes the result into the filename given by -m option.

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