riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Don't add the zlib header to SHF_COMPRESSED section 

In a SHF_COMPRESSED compressed section, the raw compressed data should
begin immediately after the compression header.  This patch removes the
extra zlib header from the SHF_COMPRESSED section.

bfd/

	* bfd.c (bfd_update_compression_header): Also write the zlib
	header if the SHF_COMPRESSED bit cleared..
	(bfd_check_compression_header): Return the uncompressed size.
	* compress.c (decompress_contents): Don't skip the zlib header.
	(bfd_compress_section_contents): Properly handle ELFCOMPRESS_ZLIB,
	which doesn't have the zlib header.
	(bfd_init_section_decompress_status): Likewise.
	(bfd_get_full_section_contents): Updated.
	(bfd_is_section_compressed): Likewise.
	(bfd_is_section_compressed_with_header): Return the uncompressed
	size.
	* elf.c (_bfd_elf_make_section_from_shdr): Updated.
	* bfd-in2.h: Regenerated.

binutils/

	* readelf.c (uncompress_section_contents): Add a parameter for
	uncompressed size.  Don't check the zlib header.
	(load_specific_debug_section): Updated.

binutils/testsuite/

	* binutils-all/compress.exp: Replace "$OBJDUMP -s -j .debug_info"
	with "$OBJDUMP -W".
	* binutils-all/libdw2-compressedgabi.out: Updated.

gas/

2015-05-14  H.J. Lu  <hongjiu.lu@intel.com>

	* write.c (compress_debug): Don't write the zlib header, which
	is handled by bfd_update_compression_header.
gdb-7.10-branch
H.J. Lu 11 years ago
parent
61a7418ccb
commit
dab394de9e
12 changed files with 544 additions and 123 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      bfd/ChangeLog
  2. 5
      bfd/bfd-in2.h
  3. 30
      bfd/bfd.c
  4. 157
      bfd/compress.c
  5. 5
      bfd/elf.c
  6. 6
      binutils/ChangeLog
  7. 46
      binutils/readelf.c
  8. 6
      binutils/testsuite/ChangeLog
  9. 3
      binutils/testsuite/binutils-all/compress.exp
  10. 363
      binutils/testsuite/binutils-all/libdw2-compressedgabi.out
  11. 5
      gas/ChangeLog
  12. 25
      gas/write.c

16
bfd/ChangeLog
View File

@ -1,3 +1,19 @@
2015-05-14 H.J. Lu <hongjiu.lu@intel.com>
* bfd.c (bfd_update_compression_header): Also write the zlib
header if the SHF_COMPRESSED bit cleared..
(bfd_check_compression_header): Return the uncompressed size.
* compress.c (decompress_contents): Don't skip the zlib header.
(bfd_compress_section_contents): Properly handle ELFCOMPRESS_ZLIB,
which doesn't have the zlib header.
(bfd_init_section_decompress_status): Likewise.
(bfd_get_full_section_contents): Updated.
(bfd_is_section_compressed): Likewise.
(bfd_is_section_compressed_with_header): Return the uncompressed
size.
* elf.c (_bfd_elf_make_section_from_shdr): Updated.
* bfd-in2.h: Regenerated.
2015-05-14 Jiong Wang <jiong.wang@arm.com>
* elfnn-aarch64.c (elfNN_aarch64_relocate_section): Remove overflow

5
bfd/bfd-in2.h
View File

@ -6816,7 +6816,7 @@ void bfd_update_compression_header
bfd_boolean bfd_check_compression_header
(bfd *abfd, bfd_byte *contents, asection *sec,
bfd_size_type uncompressed_size);
bfd_size_type *uncompressed_size);
int bfd_get_compression_header_size (bfd *abfd, asection *sec);
@ -7334,7 +7334,8 @@ void bfd_cache_section_contents
bfd_boolean bfd_is_section_compressed_with_header
(bfd *abfd, asection *section,
int *compression_header_size_p);
int *compression_header_size_p,
bfd_size_type *uncompressed_size_p);
bfd_boolean bfd_is_section_compressed
(bfd *abfd, asection *section);

30
bfd/bfd.c
View File

@ -1998,8 +1998,16 @@ bfd_update_compression_header (bfd *abfd, bfd_byte *contents,
}
}
else
/* Clear the SHF_COMPRESSED bit. */
elf_section_flags (sec) &= ~SHF_COMPRESSED;
{
/* Clear the SHF_COMPRESSED bit. */
elf_section_flags (sec) &= ~SHF_COMPRESSED;
/* Write the zlib header. It should be "ZLIB" followed by
the uncompressed section size, 8 bytes in big-endian
order. */
memcpy (contents, "ZLIB", 4);
bfd_putb64 (sec->size, contents + 4);
}
}
}
else
@ -2013,11 +2021,12 @@ bfd_update_compression_header (bfd *abfd, bfd_byte *contents,
SYNOPSIS
bfd_boolean bfd_check_compression_header
(bfd *abfd, bfd_byte *contents, asection *sec,
bfd_size_type uncompressed_size);
bfd_size_type *uncompressed_size);
DESCRIPTION
Check the compression header at CONTENTS of SEC in ABFD with
the uncompressed size UNCOMPRESSED_SIZE.
Check the compression header at CONTENTS of SEC in ABFD and
store the uncompressed size in UNCOMPRESSED_SIZE if the
compression header is valid.
RETURNS
Return TRUE if the compression header is valid.
@ -2026,7 +2035,7 @@ RETURNS
bfd_boolean
bfd_check_compression_header (bfd *abfd, bfd_byte *contents,
asection *sec,
bfd_size_type uncompressed_size)
bfd_size_type *uncompressed_size)
{
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
&& (elf_section_flags (sec) & SHF_COMPRESSED) != 0)
@ -2047,9 +2056,12 @@ bfd_check_compression_header (bfd *abfd, bfd_byte *contents,
chdr.ch_size = bfd_get_64 (abfd, &echdr->ch_size);
chdr.ch_addralign = bfd_get_64 (abfd, &echdr->ch_addralign);
}
return (chdr.ch_type == ELFCOMPRESS_ZLIB
&& chdr.ch_size == uncompressed_size
&& chdr.ch_addralign == 1U << sec->alignment_power);
if (chdr.ch_type == ELFCOMPRESS_ZLIB
&& chdr.ch_addralign == 1U << sec->alignment_power)
{
*uncompressed_size = chdr.ch_size;
return TRUE;
}
}
return FALSE;

157
bfd/compress.c
View File

@ -43,8 +43,8 @@ decompress_contents (bfd_byte *compressed_buffer,
we first zero the entire z_stream structure and then set the fields
that we need. */
memset (& strm, 0, sizeof strm);
strm.avail_in = compressed_size - 12;
strm.next_in = (Bytef*) compressed_buffer + 12;
strm.avail_in = compressed_size;
strm.next_in = (Bytef*) compressed_buffer;
strm.avail_out = uncompressed_size;
BFD_ASSERT (Z_OK == 0);
@ -81,18 +81,19 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec,
bfd_byte *buffer;
bfd_size_type buffer_size;
bfd_boolean decompress;
#if defined(__GNUC__) && GCC_VERSION < 4007
/* Work around a GCC uninitialized warning bug fixed in GCC 4.7. */
int zlib_size = 0;
#else
int zlib_size;
#endif
int orig_compression_header_size;
int compression_header_size
= bfd_get_compression_header_size (abfd, NULL);
bfd_size_type orig_uncompressed_size;
int header_size = bfd_get_compression_header_size (abfd, NULL);
bfd_boolean compressed
= bfd_is_section_compressed_with_header (abfd, sec,
&orig_compression_header_size);
&orig_compression_header_size,
&orig_uncompressed_size);
/* Either ELF compression header or the 12-byte, "ZLIB" + 8-byte size,
overhead in .zdebug* section. */
if (!header_size)
header_size = 12;
if (compressed)
{
@ -105,34 +106,34 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec,
if (orig_compression_header_size == 0)
{
/* Convert it from .zdebug* section. Get the uncompressed
size first. */
zlib_size = uncompressed_size;
compressed_size = zlib_size + compression_header_size;
uncompressed_size = bfd_getb64 (uncompressed_buffer + 4);
size first. We need to substract the 12-byte overhead in
.zdebug* section. Set orig_compression_header_size to
the 12-bye overhead. */
orig_compression_header_size = 12;
zlib_size = uncompressed_size - 12;
}
else
{
/* Convert it to .zdebug* section. */
/* Convert it to .zdebug* section. */
zlib_size = uncompressed_size - orig_compression_header_size;
compressed_size = zlib_size;
}
/* Add the header size. */
compressed_size = zlib_size + header_size;
}
else
compressed_size = compressBound (uncompressed_size) + 12;
compressed_size = compressBound (uncompressed_size) + header_size;
/* When converting from .zdebug* section, uncompress if it leads to
smaller size. */
if (compressed
&& orig_compression_header_size == 0
&& compressed_size > uncompressed_size)
/* Uncompress if it leads to smaller size. */
if (compressed && compressed_size > orig_uncompressed_size)
{
decompress = TRUE;
buffer_size = uncompressed_size;
buffer_size = orig_uncompressed_size;
}
else
{
decompress = FALSE;
buffer_size = compressed_size + compression_header_size;
buffer_size = compressed_size;
}
buffer = (bfd_byte *) bfd_alloc (abfd, buffer_size);
if (buffer == NULL)
@ -140,11 +141,12 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec,
if (compressed)
{
sec->size = uncompressed_size;
sec->size = orig_uncompressed_size;
if (decompress)
{
if (!decompress_contents (uncompressed_buffer, zlib_size,
buffer, uncompressed_size))
if (!decompress_contents (uncompressed_buffer
+ orig_compression_header_size,
zlib_size, buffer, buffer_size))
{
bfd_set_error (bfd_error_bad_value);
bfd_release (abfd, buffer);
@ -153,20 +155,18 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec,
free (uncompressed_buffer);
sec->contents = buffer;
sec->compress_status = COMPRESS_SECTION_DONE;
return uncompressed_size;
return orig_uncompressed_size;
}
else
{
bfd_update_compression_header (abfd, buffer, sec);
memmove (buffer + compression_header_size,
memmove (buffer + header_size,
uncompressed_buffer + orig_compression_header_size,
zlib_size);
}
}
else
{
bfd_size_type size = uncompressed_size;
int header_size = 12 + compression_header_size;
if (compress ((Bytef*) buffer + header_size,
&compressed_size,
(const Bytef*) uncompressed_buffer,
@ -181,15 +181,7 @@ bfd_compress_section_contents (bfd *abfd, sec_ptr sec,
/* PR binutils/18087: If compression didn't make the section smaller,
just keep it uncompressed. */
if (compressed_size < uncompressed_size)
{
bfd_update_compression_header (abfd, buffer, sec);
/* Write the zlib header. In this case, it should be "ZLIB"
followed by the uncompressed section size, 8 bytes in
big-endian order. */
memcpy (buffer + compression_header_size, "ZLIB", 4);
bfd_putb64 (size, buffer + compression_header_size + 4);
}
bfd_update_compression_header (abfd, buffer, sec);
else
{
/* NOTE: There is a small memory leak here since
@ -295,6 +287,10 @@ bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr)
goto fail_compressed;
compression_header_size = bfd_get_compression_header_size (abfd, sec);
if (compression_header_size == 0)
/* Set header size to the zlib header size if it is a
SHF_COMPRESSED section. */
compression_header_size = 12;
if (!decompress_contents (compressed_buffer + compression_header_size,
sec->compressed_size, p, sz))
{
@ -359,49 +355,56 @@ FUNCTION
SYNOPSIS
bfd_boolean bfd_is_section_compressed_with_header
(bfd *abfd, asection *section,
int *compression_header_size_p);
int *compression_header_size_p,
bfd_size_type *uncompressed_size_p);
DESCRIPTION
Return @code{TRUE} if @var{section} is compressed. Compression
header size is returned in @var{compression_header_size_p}. If
header size is returned in @var{compression_header_size_p} and
uncompressed size is returned in @var{uncompressed_size_p}. If
compression is unsupported, compression header size is returned
with -1.
with -1 and uncompressed size is returned with 0.
*/
bfd_boolean
bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec,
int *compression_header_size_p)
int *compression_header_size_p,
bfd_size_type *uncompressed_size_p)
{
bfd_byte header[MAX_COMPRESSION_HEADER_SIZE + 12];
bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
int compression_header_size;
int header_size = 12;
int header_size;
unsigned int saved = sec->compress_status;
bfd_boolean compressed;
compression_header_size = bfd_get_compression_header_size (abfd, sec);
if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
abort ();
header_size += compression_header_size;
header_size = compression_header_size ? compression_header_size : 12;
/* Don't decompress the section. */
sec->compress_status = COMPRESS_SECTION_NONE;
/* Read the zlib header. In this case, it should be "ZLIB" followed
by the uncompressed section size, 8 bytes in big-endian order. */
compressed = bfd_get_section_contents (abfd, sec, header, 0,
header_size)
&& CONST_STRNEQ ((char*) header + compression_header_size,
"ZLIB");
/* Read the header. */
if (bfd_get_section_contents (abfd, sec, header, 0, header_size))
{
if (compression_header_size == 0)
/* In this case, it should be "ZLIB" followed by the uncompressed
section size, 8 bytes in big-endian order. */
compressed = CONST_STRNEQ ((char*) header , "ZLIB");
else
compressed = TRUE;
}
else
compressed = FALSE;
*uncompressed_size_p = sec->size;
if (compressed)
{
if (compression_header_size != 0)
{
bfd_size_type uncompressed_size
= bfd_getb64 ((bfd_byte *) header
+ compression_header_size + 4);
if (!bfd_check_compression_header (abfd, header, sec,
uncompressed_size))
uncompressed_size_p))
compression_header_size = -1;
}
/* Check for the pathalogical case of a debug string section that
@ -409,8 +412,10 @@ bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec,
no uncompressed .debug_str section would ever be big enough to
have the first byte of its (big-endian) size be non-zero. */
else if (strcmp (sec->name, ".debug_str") == 0
&& ISPRINT (header[compression_header_size + 4]))
&& ISPRINT (header[4]))
compressed = FALSE;
else
*uncompressed_size_p = bfd_getb64 (header + 4);
}
/* Restore compress_status. */
@ -435,9 +440,12 @@ bfd_boolean
bfd_is_section_compressed (bfd *abfd, sec_ptr sec)
{
int compression_header_size;
bfd_size_type uncompressed_size;
return (bfd_is_section_compressed_with_header (abfd, sec,
&compression_header_size)
&& compression_header_size >= 0);
&compression_header_size,
&uncompressed_size)
&& compression_header_size >= 0
&& uncompressed_size > 0);
}
/*
@ -460,16 +468,17 @@ DESCRIPTION
bfd_boolean
bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
{
bfd_byte header[MAX_COMPRESSION_HEADER_SIZE + 12];
bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
int compression_header_size;
int header_size = 12;
int header_size;
bfd_size_type uncompressed_size;
compression_header_size = bfd_get_compression_header_size (abfd, sec);
if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
abort ();
header_size += compression_header_size;
header_size = compression_header_size ? compression_header_size : 12;
/* Read the header. */
if (sec->rawsize != 0
|| sec->contents != NULL
|| sec->compress_status != COMPRESS_SECTION_NONE
@ -479,22 +488,24 @@ bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
return FALSE;
}
/* Read the zlib header. In this case, it should be "ZLIB" followed
by the uncompressed section size, 8 bytes in big-endian order. */
if (! CONST_STRNEQ ((char*) header + compression_header_size, "ZLIB"))
if (compression_header_size == 0)
{
bfd_set_error (bfd_error_wrong_format);
return FALSE;
/* In this case, it should be "ZLIB" followed by the uncompressed
section size, 8 bytes in big-endian order. */
if (! CONST_STRNEQ ((char*) header, "ZLIB"))
{
bfd_set_error (bfd_error_wrong_format);
return FALSE;
}
uncompressed_size = bfd_getb64 (header + 4);
}
uncompressed_size = bfd_getb64 (header + compression_header_size + 4);
if (compression_header_size != 0
&& !bfd_check_compression_header (abfd, header, sec,
uncompressed_size))
else if (!bfd_check_compression_header (abfd, header, sec,
&uncompressed_size))
{
bfd_set_error (bfd_error_wrong_format);
return FALSE;
}
sec->compressed_size = sec->size;
sec->size = uncompressed_size;
sec->compress_status = DECOMPRESS_SECTION_SIZED;

5
bfd/elf.c
View File

@ -1067,9 +1067,11 @@ _bfd_elf_make_section_from_shdr (bfd *abfd,
{
enum { nothing, compress, decompress } action = nothing;
int compression_header_size;
bfd_size_type uncompressed_size;
bfd_boolean compressed
= bfd_is_section_compressed_with_header (abfd, newsect,
&compression_header_size);
&compression_header_size,
&uncompressed_size);
if (compressed)
{
@ -1085,6 +1087,7 @@ _bfd_elf_make_section_from_shdr (bfd *abfd,
if (newsect->size != 0
&& (abfd->flags & BFD_COMPRESS)
&& compression_header_size >= 0
&& uncompressed_size > 0
&& (!compressed
|| ((compression_header_size > 0)
!= ((abfd->flags & BFD_COMPRESS_GABI) != 0))))

6
binutils/ChangeLog
View File

@ -1,3 +1,9 @@
2015-05-14 H.J. Lu <hongjiu.lu@intel.com>
* readelf.c (uncompress_section_contents): Add a parameter for
uncompressed size. Don't check the zlib header.
(load_specific_debug_section): Updated.
2015-05-13 H.J. Lu <hongjiu.lu@intel.com>
* elfedit.c (elf_class): Return ELF_CLASS_BOTH by default.

46
binutils/readelf.c
View File

@ -12074,30 +12074,14 @@ dump_section_as_bytes (Elf_Internal_Shdr * section,
static int
uncompress_section_contents (unsigned char **buffer,
dwarf_size_type uncompressed_size,
dwarf_size_type *size)
{
dwarf_size_type compressed_size = *size;
unsigned char * compressed_buffer = *buffer;
dwarf_size_type uncompressed_size;
unsigned char * uncompressed_buffer;
z_stream strm;
int rc;
dwarf_size_type header_size = 12;
/* Read the zlib header. In this case, it should be "ZLIB" followed
by the uncompressed section size, 8 bytes in big-endian order. */
if (compressed_size < header_size
|| ! streq ((char *) compressed_buffer, "ZLIB"))
return 0;
uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[11];
/* It is possible the section consists of several compressed
buffers concatenated together, so we uncompress in a loop. */
@ -12107,8 +12091,8 @@ uncompress_section_contents (unsigned char **buffer,
we first zero the entire z_stream structure and then set the fields
that we need. */
memset (& strm, 0, sizeof strm);
strm.avail_in = compressed_size - header_size;
strm.next_in = (Bytef *) compressed_buffer + header_size;
strm.avail_in = compressed_size;
strm.next_in = (Bytef *) compressed_buffer;
strm.avail_out = uncompressed_size;
uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
@ -12163,6 +12147,7 @@ load_specific_debug_section (enum dwarf_section_display_enum debug,
{
unsigned char *start = section->start;
dwarf_size_type size = sec->sh_size;
dwarf_size_type uncompressed_size = 0;
if ((sec->sh_flags & SHF_COMPRESSED) != 0)
{
@ -12172,11 +12157,30 @@ load_specific_debug_section (enum dwarf_section_display_enum debug,
if (chdr.ch_type != ELFCOMPRESS_ZLIB
|| chdr.ch_addralign != sec->sh_addralign)
return 0;
uncompressed_size = chdr.ch_size;
start += compression_header_size;
size -= compression_header_size;
}
if (uncompress_section_contents (&start, &size))
else if (size > 12 && streq ((char *) start, "ZLIB"))
{
/* Read the zlib header. In this case, it should be "ZLIB"
followed by the uncompressed section size, 8 bytes in
big-endian order. */
uncompressed_size = start[4]; uncompressed_size <<= 8;
uncompressed_size += start[5]; uncompressed_size <<= 8;
uncompressed_size += start[6]; uncompressed_size <<= 8;
uncompressed_size += start[7]; uncompressed_size <<= 8;
uncompressed_size += start[8]; uncompressed_size <<= 8;
uncompressed_size += start[9]; uncompressed_size <<= 8;
uncompressed_size += start[10]; uncompressed_size <<= 8;
uncompressed_size += start[11];
start += 12;
size -= 12;
}
if (uncompressed_size
&& uncompress_section_contents (&start, uncompressed_size,
&size))
{
/* Free the compressed buffer, update the section buffer
and the section size if uncompress is successful. */

6
binutils/testsuite/ChangeLog
View File

@ -1,3 +1,9 @@
2015-05-14 H.J. Lu <hongjiu.lu@intel.com>
* binutils-all/compress.exp: Replace "$OBJDUMP -s -j .debug_info"
with "$OBJDUMP -W".
* binutils-all/libdw2-compressedgabi.out: Updated.
2015-05-12 H.J. Lu <hongjiu.lu@intel.com>
* binutils-all/elfedit-1.d: Also skip x86_64-*-nacl*.

3
binutils/testsuite/binutils-all/compress.exp
View File

@ -544,8 +544,7 @@ set got [binutils_run $OBJCOPY "--compress-debug-sections=zlib-gabi ${copyfile}g
if ![string match "" $got] then {
fail "objcopy ($testname)"
} else {
set got [remote_exec host "$OBJDUMP -s -j .debug_info
${compressedcopyfile}gabi.a" "" "/dev/null" "tmpdir/libdw2-compressedgabi.out"]
set got [remote_exec host "$OBJDUMP -W ${compressedcopyfile}gabi.a" "" "/dev/null" "tmpdir/libdw2-compressedgabi.out"]
if { [lindex $got 0] != 0 || ![string match "" [lindex $got 1]] } then {
fail "$testname (reason: unexpected output)"

363
binutils/testsuite/binutils-all/libdw2-compressedgabi.out
View File

@ -1,3 +1,362 @@
#...
.*ZLIB.*
In archive tmpdir/dw2-copy-compressedgabi.a:
dw2-1-compressedgabi.o: +file format .*
Contents of the .debug_info section:
Compilation Unit @ offset 0x0:
Length: 0x4e \(32-bit\)
Version: 2
Abbrev Offset: 0x0
Pointer Size: 4
<0><b>: Abbrev Number: 1 \(DW_TAG_compile_unit\)
<c> DW_AT_stmt_list : 0x0
<10> DW_AT_high_pc : 0x.
<14> DW_AT_low_pc : 0x.
<18> DW_AT_name : file1.txt
<22> DW_AT_producer : GNU C 3.3.3
<2e> DW_AT_language : 1 \(ANSI C\)
<1><2f>: Abbrev Number: 2 \(DW_TAG_subprogram\)
<30> DW_AT_external : 1
<31> DW_AT_decl_file : 1
<32> DW_AT_decl_line : 2
<33> DW_AT_name : func_cu1
<3c> DW_AT_type : <0x4a>
<40> DW_AT_low_pc : 0x.
<44> DW_AT_high_pc : 0x.
<48> DW_AT_frame_base : 1 byte block: 55 \(DW_OP_reg5 \([^()]*\)\)
<1><4a>: Abbrev Number: 3 \(DW_TAG_base_type\)
<4b> DW_AT_name : int
<4f> DW_AT_byte_size : 4
<50> DW_AT_encoding : 5 \(signed\)
<1><51>: Abbrev Number: 0
Raw dump of debug contents of section .debug_line:
Offset: 0x0
Length: 62
DWARF Version: 2
Prologue Length: 35
Minimum Instruction Length: 1
Initial value of 'is_stmt': 1
Line Base: 1
Line Range: 1
Opcode Base: 16
Opcodes:
Opcode 1 has 0 args
Opcode 2 has 1 args
Opcode 3 has 1 args
Opcode 4 has 1 args
Opcode 5 has 1 args
Opcode 6 has 0 args
Opcode 7 has 0 args
Opcode 8 has 0 args
Opcode 9 has 1 args
Opcode 10 has 0 args
Opcode 11 has 0 args
Opcode 12 has 1 args
Opcode 13 has 0 args
Opcode 14 has 0 args
Opcode 15 has 0 args
The Directory Table is empty.
The File Name Table \(offset 0x.*\):
Entry Dir Time Size Name
1 0 0 0 file1.txt
Line Number Statements:
\[0x.*\] Extended opcode 2: set Address to 0x4
\[0x.*\] Advance Line by 3 to 4
\[0x.*\] Copy
\[0x.*\] Copy
\[0x.*\] Extended opcode 2: set Address to 0x8
\[0x.*\] Extended opcode 1: End of Sequence
Contents of the .debug_abbrev section:
Number TAG \(0x0\)
1 DW_TAG_compile_unit \[has children\]
DW_AT_stmt_list DW_FORM_data4
DW_AT_high_pc DW_FORM_addr
DW_AT_low_pc DW_FORM_addr
DW_AT_name DW_FORM_string
DW_AT_producer DW_FORM_string
DW_AT_language DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
2 DW_TAG_subprogram \[no children\]
DW_AT_external DW_FORM_flag
DW_AT_decl_file DW_FORM_data1
DW_AT_decl_line DW_FORM_data1
DW_AT_name DW_FORM_string
DW_AT_type DW_FORM_ref4
DW_AT_low_pc DW_FORM_addr
DW_AT_high_pc DW_FORM_addr
DW_AT_frame_base DW_FORM_block1
DW_AT value: 0 DW_FORM value: 0
3 DW_TAG_base_type \[no children\]
DW_AT_name DW_FORM_string
DW_AT_byte_size DW_FORM_data1
DW_AT_encoding DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
dw2-2-compressedgabi.o: +file format .*
Contents of the .debug_info section:
Compilation Unit @ offset 0x0:
Length: 0x4e \(32-bit\)
Version: 2
Abbrev Offset: 0x0
Pointer Size: 4
<0><b>: Abbrev Number: 1 \(DW_TAG_compile_unit\)
<c> DW_AT_stmt_list : 0x0
<10> DW_AT_high_pc : 0x4
<14> DW_AT_low_pc : 0x0
<18> DW_AT_name : file1.txt
<22> DW_AT_producer : GNU C 3.3.3
<2e> DW_AT_language : 1 \(ANSI C\)
<1><2f>: Abbrev Number: 2 \(DW_TAG_subprogram\)
<30> DW_AT_external : 1
<31> DW_AT_decl_file : 1
<32> DW_AT_decl_line : 2
<33> DW_AT_name : func_cu2
<3c> DW_AT_type : <0x4a>
<40> DW_AT_low_pc : 0x0
<44> DW_AT_high_pc : 0x4
<48> DW_AT_frame_base : 1 byte block: 55 \(DW_OP_reg5 \(.*\)\)
<1><4a>: Abbrev Number: 3 \(DW_TAG_base_type\)
<4b> DW_AT_name : int
<4f> DW_AT_byte_size : 4
<50> DW_AT_encoding : 5 \(signed\)
<1><51>: Abbrev Number: 0
Raw dump of debug contents of section .debug_line:
Offset: 0x0
Length: 62
DWARF Version: 2
Prologue Length: 35
Minimum Instruction Length: 1
Initial value of 'is_stmt': 1
Line Base: 1
Line Range: 1
Opcode Base: 16
Opcodes:
Opcode 1 has 0 args
Opcode 2 has 1 args
Opcode 3 has 1 args
Opcode 4 has 1 args
Opcode 5 has 1 args
Opcode 6 has 0 args
Opcode 7 has 0 args
Opcode 8 has 0 args
Opcode 9 has 1 args
Opcode 10 has 0 args
Opcode 11 has 0 args
Opcode 12 has 1 args
Opcode 13 has 0 args
Opcode 14 has 0 args
Opcode 15 has 0 args
The Directory Table is empty.
The File Name Table \(offset 0x1f\):
Entry Dir Time Size Name
1 0 0 0 file1.txt
Line Number Statements:
\[0x0000002d\] Extended opcode 2: set Address to 0x0
\[0x00000034\] Advance Line by 3 to 4
\[0x00000036\] Copy
\[0x00000037\] Copy
\[0x00000038\] Extended opcode 2: set Address to 0x4
\[0x0000003f\] Extended opcode 1: End of Sequence
Contents of the .debug_abbrev section:
Number TAG \(0x0\)
1 DW_TAG_compile_unit \[has children\]
DW_AT_stmt_list DW_FORM_data4
DW_AT_high_pc DW_FORM_addr
DW_AT_low_pc DW_FORM_addr
DW_AT_name DW_FORM_string
DW_AT_producer DW_FORM_string
DW_AT_language DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
2 DW_TAG_subprogram \[no children\]
DW_AT_external DW_FORM_flag
DW_AT_decl_file DW_FORM_data1
DW_AT_decl_line DW_FORM_data1
DW_AT_name DW_FORM_string
DW_AT_type DW_FORM_ref4
DW_AT_low_pc DW_FORM_addr
DW_AT_high_pc DW_FORM_addr
DW_AT_frame_base DW_FORM_block1
DW_AT value: 0 DW_FORM value: 0
3 DW_TAG_base_type \[no children\]
DW_AT_name DW_FORM_string
DW_AT_byte_size DW_FORM_data1
DW_AT_encoding DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
dw2-3-compressedgabi.o: +file format .*
Contents of the .debug_info section:
Compilation Unit @ offset 0x0:
Length: 0x5e \(32-bit\)
Version: 2
Abbrev Offset: 0x0
Pointer Size: 4
<0><b>: Abbrev Number: 1 \(DW_TAG_compile_unit\)
<c> DW_AT_stmt_list : 0x0
<10> DW_AT_high_pc : 0x4
<14> DW_AT_low_pc : 0x0
<18> DW_AT_name : file1.txt
<22> DW_AT_producer : GNU C 3.3.3
<2e> DW_AT_language : 1 \(ANSI C\)
<1><2f>: Abbrev Number: 2 \(DW_TAG_subprogram\)
<30> DW_AT_external : 1
<31> DW_AT_decl_file : 1
<32> DW_AT_decl_line : 2
<33> DW_AT_name : func_cu1
<3c> DW_AT_type : <0x85>
<40> DW_AT_low_pc : 0x0
<44> DW_AT_high_pc : 0x4
<48> DW_AT_frame_base : 1 byte block: 55 \(DW_OP_reg5 \([^()]*\)\)
<1><4a>: Abbrev Number: 3 \(DW_TAG_base_type\)
<4b> DW_AT_name : int1
<50> DW_AT_byte_size : 4
<51> DW_AT_encoding : 5 \(signed\)
<1><52>: Abbrev Number: 4 \(DW_TAG_const_type\)
<53> DW_AT_type : <0x4a>
<1><57>: Abbrev Number: 5 \(DW_TAG_variable\)
<58> DW_AT_name : one
<5c> DW_AT_type : <0x52>
<60> DW_AT_const_value : 1
<1><61>: Abbrev Number: 0
Compilation Unit @ offset 0x62:
Length: 0x37 \(32-bit\)
Version: 2
Abbrev Offset: 0x45
Pointer Size: 4
<0><6d>: Abbrev Number: 1 \(DW_TAG_compile_unit\)
<6e> DW_AT_name : file1.txt
<78> DW_AT_producer : GNU C 3.3.3
<84> DW_AT_language : 1 \(ANSI C\)
<1><85>: Abbrev Number: 2 \(DW_TAG_base_type\)
<86> DW_AT_name : int2
<8b> DW_AT_byte_size : 4
<8c> DW_AT_encoding : 5 \(signed\)
<1><8d>: Abbrev Number: 3 \(DW_TAG_const_type\)
<8e> DW_AT_type : <0x85>
<1><92>: Abbrev Number: 4 \(DW_TAG_variable\)
<93> DW_AT_name : two
<97> DW_AT_type : <0x8d>
<9b> DW_AT_const_value : 2
<1><9c>: Abbrev Number: 0
Contents of the .debug_abbrev section:
Number TAG \(0x0\)
1 DW_TAG_compile_unit \[has children\]
DW_AT_stmt_list DW_FORM_data4
DW_AT_high_pc DW_FORM_addr
DW_AT_low_pc DW_FORM_addr
DW_AT_name DW_FORM_string
DW_AT_producer DW_FORM_string
DW_AT_language DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
2 DW_TAG_subprogram \[no children\]
DW_AT_external DW_FORM_flag
DW_AT_decl_file DW_FORM_data1
DW_AT_decl_line DW_FORM_data1
DW_AT_name DW_FORM_string
DW_AT_type DW_FORM_ref_addr
DW_AT_low_pc DW_FORM_addr
DW_AT_high_pc DW_FORM_addr
DW_AT_frame_base DW_FORM_block1
DW_AT value: 0 DW_FORM value: 0
3 DW_TAG_base_type \[no children\]
DW_AT_name DW_FORM_string
DW_AT_byte_size DW_FORM_data1
DW_AT_encoding DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
4 DW_TAG_const_type \[no children\]
DW_AT_type DW_FORM_ref4
DW_AT value: 0 DW_FORM value: 0
5 DW_TAG_variable \[no children\]
DW_AT_name DW_FORM_string
DW_AT_type DW_FORM_ref4
DW_AT_const_value DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
Number TAG \(0x45\)
1 DW_TAG_compile_unit \[has children\]
DW_AT_name DW_FORM_string
DW_AT_producer DW_FORM_string
DW_AT_language DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
2 DW_TAG_base_type \[no children\]
DW_AT_name DW_FORM_string
DW_AT_byte_size DW_FORM_data1
DW_AT_encoding DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
3 DW_TAG_const_type \[no children\]
DW_AT_type DW_FORM_ref4
DW_AT value: 0 DW_FORM value: 0
4 DW_TAG_variable \[no children\]
DW_AT_name DW_FORM_string
DW_AT_type DW_FORM_ref4
DW_AT_const_value DW_FORM_data1
DW_AT value: 0 DW_FORM value: 0
Raw dump of debug contents of section .debug_line:
Offset: 0x0
Length: 62
DWARF Version: 2
Prologue Length: 35
Minimum Instruction Length: 1
Initial value of 'is_stmt': 1
Line Base: 1
Line Range: 1
Opcode Base: 16
Opcodes:
Opcode 1 has 0 args
Opcode 2 has 1 args
Opcode 3 has 1 args
Opcode 4 has 1 args
Opcode 5 has 1 args
Opcode 6 has 0 args
Opcode 7 has 0 args
Opcode 8 has 0 args
Opcode 9 has 1 args
Opcode 10 has 0 args
Opcode 11 has 0 args
Opcode 12 has 1 args
Opcode 13 has 0 args
Opcode 14 has 0 args
Opcode 15 has 0 args
The Directory Table is empty.
The File Name Table \(offset 0x1f\):
Entry Dir Time Size Name
1 0 0 0 file1.txt
Line Number Statements:
\[0x0000002d\] Extended opcode 2: set Address to 0x0
\[0x00000034\] Advance Line by 3 to 4
\[0x00000036\] Copy
\[0x00000037\] Copy
\[0x00000038\] Extended opcode 2: set Address to 0x4
\[0x0000003f\] Extended opcode 1: End of Sequence
#pass

5
gas/ChangeLog
View File

@ -1,3 +1,8 @@
2015-05-14 H.J. Lu <hongjiu.lu@intel.com>
* write.c (compress_debug): Don't write the zlib header, which
is handled by bfd_update_compression_header.
2015-05-13 Max Filippov <jcmvbkbc@gmail.com>
* config/tc-xtensa.c (xtensa_relax_frag): Allow trampoline to be

25
gas/write.c
View File

@ -1414,8 +1414,6 @@ compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
int x;
flagword flags = bfd_get_section_flags (abfd, sec);
unsigned int header_size, compression_header_size;
/* Maximimum compression header is 24 bytes. */
bfd_byte compression_header[24];
if (seginfo == NULL
|| sec->size < 32
@ -1431,14 +1429,20 @@ compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
return;
if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
{
stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
compression_header_size
= bfd_get_compression_header_size (stdoutput, NULL);
header_size = compression_header_size;
}
else
stdoutput->flags |= BFD_COMPRESS;
compression_header_size
= bfd_get_compression_header_size (stdoutput, NULL);
{
stdoutput->flags |= BFD_COMPRESS;
compression_header_size = 0;
header_size = 12;
}
/* Create a new frag to contain the "ZLIB" header. */
header_size = 12 + compression_header_size;
/* Create a new frag to contain the compression header. */
first_newf = frag_alloc (ob);
if (obstack_room (ob) < header_size)
first_newf = frag_alloc (ob);
@ -1533,11 +1537,6 @@ compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
if (compressed_size >= uncompressed_size)
return;
if (compression_header_size)
memcpy (header, compression_header, compression_header_size);
memcpy (header + compression_header_size, "ZLIB", 4);
bfd_putb64 (uncompressed_size, header + compression_header_size + 4);
/* Replace the uncompressed frag list with the compressed frag list. */
seginfo->frchainP->frch_root = first_newf;
seginfo->frchainP->frch_last = last_newf;

Write Preview
Loading…
Cancel
Save