__gnu_cxx::__freeres() cleanup function is called or not. Default is
'yes'.
+* Valgrind is able to read compressed debuginfo sections in two formats:
+ - zlib ELF gABI format with SHF_COMPRESSED flag (gcc option -gz=zlib)
+ - zlib GNU format with .zdebug sections (gcc option -gz=zlib-gnu)
+
* ==================== FIXED BUGS ====================
The following bugs have been fixed or resolved. Note that "n-i-bz"
191069 Exiting due to signal not reported in XML output
212352 vex amd64 unhandled opc_aux = 0x 2, first_opcode == 0xDC (FCOM)
278744 cvtps2pd with redundant RexW
+303877 valgrind doesn't support compressed debuginfo sections.
345307 Warning about "still reachable" memory when using libstdc++ from gcc 5
348345 Assertion fails for negative lineno
353083 arm64 doesn't implement various xattr system calls
])
+# Check for ELF32/64_CHDR
+
+AC_CHECK_TYPES([Elf32_Chdr, Elf64_Chdr], [], [], [[#include <elf.h>]])
+
+
# Check for PTHREAD_RWLOCK_T
AC_MSG_CHECKING([for pthread_rwlock_t])
CFLAGS=$safe_CFLAGS
+# does this compiler support -g -gz=zlib ?
+
+AC_MSG_CHECKING([if gcc accepts -g -gz=zlib])
+
+safe_CFLAGS=$CFLAGS
+CFLAGS="-g -gz=zlib"
+
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
+ return 0;
+]])], [
+ac_have_gz_zlib=yes
+AC_MSG_RESULT([yes])
+], [
+ac_have_gz_zlib=no
+AC_MSG_RESULT([no])
+])
+AM_CONDITIONAL(GZ_ZLIB, test x$ac_have_gz_zlib = xyes)
+CFLAGS=$safe_CFLAGS
+
+
+# does this compiler support -g -gz=zlib-gnu ?
+
+AC_MSG_CHECKING([if gcc accepts -g -gz=zlib-gnu])
+
+safe_CFLAGS=$CFLAGS
+CFLAGS="-g -gz=zlib-gnu"
+
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
+ return 0;
+]])], [
+ac_have_gz_zlib_gnu=yes
+AC_MSG_RESULT([yes])
+], [
+ac_have_gz_zlib_gnu=no
+AC_MSG_RESULT([no])
+])
+AM_CONDITIONAL(GZ_ZLIB_GNU, test x$ac_have_gz_zlib_gnu = xyes)
+CFLAGS=$safe_CFLAGS
+
+
# does this compiler support nested functions ?
AC_MSG_CHECKING([if gcc accepts nested functions])
[Define to 1 if fpregset_t defines struct _fpchip_state])
fi
-
else
AM_CONDITIONAL(SOLARIS_SUN_STUDIO_AS, false)
AM_CONDITIONAL(SOLARIS_XPG_SYMBOLS_PRESENT, false)
m_debuginfo/readmacho.c \
m_debuginfo/readpdb.c \
m_debuginfo/storage.c \
+ m_debuginfo/tinfl.c \
m_debuginfo/tytypes.c \
m_demangle/cp-demangle.c \
m_demangle/cplus-dem.c \
#include "priv_image.h" /* self */
#include "minilzo.h"
+#define TINFL_HEADER_FILE_ONLY
+#include "tinfl.c"
/* These values (1024 entries of 8192 bytes each) gives a cache
size of 8MB. */
#define CACHE_ENTRY_SIZE (1 << CACHE_ENTRY_SIZE_BITS)
+#define COMMPRESSED_SLICE_ARRAY_GROW_SIZE 64
+
/* An entry in the cache. */
typedef
struct {
- DiOffT off; // file offset for data[0]
- SizeT used; // 1 .. sizeof(data), or 0 to denote not-in-use
- UChar data[CACHE_ENTRY_SIZE];
+ DiOffT off; // file offset for data[0]
+ SizeT size; // sizeof(data)
+ SizeT used; // 1 .. sizeof(data), or 0 to denote not-in-use
+ UChar data[];
}
CEnt;
+/* Compressed slice */
+typedef
+ struct {
+ DiOffT offD; // offset of decompressed data
+ SizeT szD; // size of decompressed data
+ DiOffT offC; // offset of compressed data
+ SizeT szC; // size of compressed data
+ }
+ CSlc;
+
/* Source for files */
typedef
struct {
struct _DiImage {
// The source -- how to get hold of the file we are reading
Source source;
- // Total size of the image.
+ // Virtual size of the image = real size + size of uncompressed data
SizeT size;
+ // Real size of image
+ SizeT real_size;
// The number of entries used. 0 .. CACHE_N_ENTRIES
UInt ces_used;
// Pointers to the entries. ces[0 .. ces_used-1] are non-NULL.
// The non-NULL entries may be arranged arbitrarily. We expect to use
// a pseudo-LRU scheme though.
CEnt* ces[CACHE_N_ENTRIES];
+
+ // Array of compressed slices
+ CSlc* cslc;
+ // Number of compressed slices used
+ UInt cslc_used;
+ // Size of cslc array
+ UInt cslc_size;
};
/* A frame. The first 4 bytes of |data| give the kind of the frame,
/* This assertion is checked by set_CEnt, so checking it here has
no benefit, whereas skipping it does remove it from the hottest
path. */
- /* vg_assert(cent->used > 0 && cent->used <= CACHE_ENTRY_SIZE); */
+ /* vg_assert(cent->used > 0 && cent->used <= cent->size); */
/* What we want to return is:
cent->off <= off && off < cent->off + cent->used;
This is however a very hot path, so here's alternative that uses
return off - cent->off < cent->used;
}
+/* Returns pointer to CSlc or NULL */
+static inline CSlc* find_cslc ( DiImage* img, DiOffT off )
+{
+ for (UInt i = 0; i < img->cslc_used; i++) {
+ if ( (img->cslc[i].offD <= off)
+ && (img->cslc[i].offD + img->cslc[i].szD > off)
+ )
+ return &img->cslc[i];
+ }
+ return NULL;
+}
+
/* Allocate a new CEnt, connect it to |img|, and return its index. */
-static UInt alloc_CEnt ( DiImage* img )
+static UInt alloc_CEnt ( DiImage* img, SizeT szB )
{
- vg_assert(img);
+ vg_assert(img != NULL);
vg_assert(img->ces_used < CACHE_N_ENTRIES);
+ vg_assert(szB >= CACHE_ENTRY_SIZE);
UInt entNo = img->ces_used;
img->ces_used++;
vg_assert(img->ces[entNo] == NULL);
- img->ces[entNo] = ML_(dinfo_zalloc)("di.alloc_CEnt.1", sizeof(CEnt));
+ img->ces[entNo] = ML_(dinfo_zalloc)("di.alloc_CEnt.1",
+ offsetof(CEnt, data) + szB);
+ img->ces[entNo]->size = szB;
return entNo;
}
+static void realloc_CEnt ( DiImage* img, UInt entNo, SizeT szB ) {
+ vg_assert(img != NULL);
+ vg_assert(szB >= CACHE_ENTRY_SIZE);
+ img->ces[entNo] = ML_(dinfo_realloc)("di.realloc_CEnt.1",
+ img->ces[entNo],
+ offsetof(CEnt, data) + szB);
+}
+
/* Move the given entry to the top and slide those above it down by 1,
to make space. */
static void move_CEnt_to_top ( DiImage* img, UInt entNo )
{
SizeT len;
DiOffT off_orig = off;
- vg_assert(img);
+ vg_assert(img != NULL);
vg_assert(img->ces_used <= CACHE_N_ENTRIES);
vg_assert(entNo >= 0 && entNo < img->ces_used);
- vg_assert(off < img->size);
- vg_assert(img->ces[entNo] != NULL);
+ vg_assert(off < img->real_size);
+ CEnt* ce = img->ces[entNo];
+ vg_assert(ce != NULL);
/* Compute [off, +len) as the slice we are going to read. */
off = block_round_down(off);
- len = img->size - off;
- if (len > CACHE_ENTRY_SIZE) len = CACHE_ENTRY_SIZE;
+ len = img->real_size - off;
+ if (len > ce->size)
+ len = ce->size;
/* It is conceivable that the 'len > 0' bit could fail if we make
an image with a zero sized file. But then no 'get' request on
that image would be valid. */
- vg_assert(len > 0 && len <= CACHE_ENTRY_SIZE);
- vg_assert(off + len <= img->size);
+ vg_assert(len > 0 && len <= ce->size);
+ vg_assert(off + len <= img->real_size);
vg_assert(off <= off_orig && off_orig < off+len);
/* So, read off .. off+len-1 into the entry. */
- CEnt* ce = img->ces[entNo];
if (0) {
static UInt t_last = 0;
ce->off = off;
ce->used = len;
- vg_assert(ce->used > 0 && ce->used <= CACHE_ENTRY_SIZE);
+ vg_assert(ce->used > 0 && ce->used <= ce->size);
}
__attribute__((noinline))
if (i == img->ces_used) {
/* It's not in any entry. Either allocate a new entry or
recycle the LRU one. */
+
+ CSlc* cslc = find_cslc(img, off);
+ UChar* buf = NULL;
+ if (cslc != NULL) {
+ SizeT len = 0;
+ buf = ML_(dinfo_zalloc)("di.image.get_slowcase.1", cslc->szC);
+ // get compressed data
+ while (len < cslc->szC)
+ len += ML_(img_get_some)(buf + len, img, cslc->offC + len,
+ cslc->szC - len);
+ }
+
if (img->ces_used == CACHE_N_ENTRIES) {
/* All entries in use. Recycle the (ostensibly) LRU one. */
- set_CEnt(img, CACHE_N_ENTRIES-1, off);
i = CACHE_N_ENTRIES-1;
+ if ((cslc != NULL) && (cslc->szD > img->ces[i]->size))
+ realloc_CEnt(img, i, cslc->szD);
} else {
/* Allocate a new one, and fill it in. */
- UInt entNo = alloc_CEnt(img);
- set_CEnt(img, entNo, off);
- i = entNo;
+ SizeT size = CACHE_ENTRY_SIZE;
+ if ((cslc != NULL) && (cslc->szD > CACHE_ENTRY_SIZE))
+ size = cslc->szD;
+ i = alloc_CEnt(img, size);
+ }
+
+ if (cslc != NULL) {
+ SizeT len = tinfl_decompress_mem_to_mem(
+ img->ces[i]->data, cslc->szD,
+ buf, cslc->szC,
+ TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF
+ | TINFL_FLAG_PARSE_ZLIB_HEADER);
+ vg_assert(len == cslc->szD);
+ img->ces[i]->used = cslc->szD;
+ img->ces[i]->off = cslc->offD;
+ ML_(dinfo_free)(buf);
+ } else {
+ set_CEnt(img, i, off);
}
+
} else {
/* We found it at position 'i'. */
vg_assert(i > 0);
img->source.is_local = True;
img->source.fd = sr_Res(fd);
img->size = size;
+ img->real_size = size;
img->ces_used = 0;
img->source.name = ML_(dinfo_strdup)("di.image.ML_iflf.2", fullpath);
+ img->cslc = NULL;
+ img->cslc_size = 0;
+ img->cslc_used = 0;
/* img->ces is already zeroed out */
vg_assert(img->source.fd >= 0);
loading it at this point forcing img->cent[0] to always be
non-empty, thereby saving us an is-it-empty check on the fast
path in get(). */
- UInt entNo = alloc_CEnt(img);
+ UInt entNo = alloc_CEnt(img, CACHE_ENTRY_SIZE);
vg_assert(entNo == 0);
set_CEnt(img, 0, 0);
img->source.fd = sd;
img->source.session_id = session_id;
img->size = size;
+ img->real_size = size;
img->ces_used = 0;
img->source.name = ML_(dinfo_zalloc)("di.image.ML_ifds.2",
20 + VG_(strlen)(filename)
+ VG_(strlen)(serverAddr));
VG_(sprintf)(img->source.name, "%s at %s", filename, serverAddr);
+ img->cslc = NULL;
+ img->cslc_size = 0;
+ img->cslc_used = 0;
/* img->ces is already zeroed out */
vg_assert(img->source.fd >= 0);
/* See comment on equivalent bit in ML_(img_from_local_file) for
rationale. */
- UInt entNo = alloc_CEnt(img);
+ UInt entNo = alloc_CEnt(img, CACHE_ENTRY_SIZE);
vg_assert(entNo == 0);
set_CEnt(img, 0, 0);
return NULL;
}
+DiOffT ML_(img_mark_compressed_part)(DiImage* img, DiOffT offset, SizeT szC,
+ SizeT szD)
+{
+ DiOffT ret;
+ vg_assert(img != NULL);
+ vg_assert(offset + szC <= img->size);
+
+ if (img->cslc_used == img->cslc_size) {
+ img->cslc_size += COMMPRESSED_SLICE_ARRAY_GROW_SIZE;
+ img->cslc = ML_(dinfo_realloc)("di.image.ML_img_mark_compressed_part.1",
+ img->cslc, img->cslc_size * sizeof(CSlc));
+ }
+
+ ret = img->size;
+ img->cslc[img->cslc_used].offC = offset;
+ img->cslc[img->cslc_used].szC = szC;
+ img->cslc[img->cslc_used].offD = img->size;
+ img->cslc[img->cslc_used].szD = szD;
+ img->size += szD;
+ img->cslc_used++;
+ return ret;
+}
+
void ML_(img_done)(DiImage* img)
{
- vg_assert(img);
+ vg_assert(img != NULL);
if (img->source.is_local) {
/* Close the file; nothing else to do. */
vg_assert(img->source.session_id == 0);
vg_assert(img->ces[i] == NULL);
}
ML_(dinfo_free)(img->source.name);
+ ML_(dinfo_free)(img->cslc);
ML_(dinfo_free)(img);
}
DiOffT ML_(img_size)(const DiImage* img)
{
- vg_assert(img);
+ vg_assert(img != NULL);
return img->size;
}
+DiOffT ML_(img_real_size)(const DiImage* img)
+{
+ vg_assert(img != NULL);
+ return img->real_size;
+}
+
inline Bool ML_(img_valid)(const DiImage* img, DiOffT offset, SizeT size)
{
- vg_assert(img);
+ vg_assert(img != NULL);
vg_assert(offset != DiOffT_INVALID);
return img->size > 0 && offset + size <= (DiOffT)img->size;
}
void ML_(img_get)(/*OUT*/void* dst,
DiImage* img, DiOffT offset, SizeT size)
{
- vg_assert(img);
+ vg_assert(img != NULL);
vg_assert(size > 0);
ensure_valid(img, offset, size, "ML_(img_get)");
SizeT i;
SizeT ML_(img_get_some)(/*OUT*/void* dst,
DiImage* img, DiOffT offset, SizeT size)
{
- vg_assert(img);
+ vg_assert(img != NULL);
vg_assert(size > 0);
ensure_valid(img, offset, size, "ML_(img_get_some)");
UChar* dstU = (UChar*)dst;
0x2d02ef8d
};
- vg_assert(img);
+ vg_assert(img != NULL);
/* If the image is local, calculate the CRC here directly. If it's
remote, forward the request to the server. */
/* Destroy an existing image. */
void ML_(img_done)(DiImage*);
-/* How big is the image? */
+/* Virtual size of the image. */
DiOffT ML_(img_size)(const DiImage* img);
+/* Real size of the image. */
+DiOffT ML_(img_real_size)(const DiImage* img);
+
/* Does the section [offset, +size) exist in the image? */
Bool ML_(img_valid)(const DiImage* img, DiOffT offset, SizeT size);
connection, making the client/server split pointless. */
UInt ML_(img_calc_gnu_debuglink_crc32)(DiImage* img);
+/* Mark compressed part of image defined with (offset, szC).
+ szD is length of uncompressed data (should be known before decompression).
+ Returns (virtual) position in image from which decompressed data can be
+ read. */
+DiOffT ML_(img_mark_compressed_part)(DiImage* img, DiOffT offset, SizeT szC,
+ SizeT szD);
+
/*------------------------------------------------------------*/
/*--- DiCursor -- cursors for reading images ---*/
#endif
/* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
+#if !defined(HAVE_ELF32_CHDR)
+ typedef struct {
+ Elf32_Word ch_type;
+ Elf32_Word ch_size;
+ Elf32_Word ch_addralign;
+ } Elf32_Chdr;
+#endif
+
+#if !defined(HAVE_ELF64_CHDR)
+ typedef struct {
+ Elf64_Word ch_type;
+ Elf64_Word ch_reserved;
+ Elf64_Xword ch_size;
+ Elf64_Xword ch_addralign;
+ } Elf64_Chdr;
+#endif
+
+#if !defined(SHF_COMPRESSED)
+ #define SHF_COMPRESSED (1 << 11)
+#endif
+
+#if !defined(ELFCOMPRESS_ZLIB)
+ #define ELFCOMPRESS_ZLIB 1
+#endif
+
+#define SIZE_OF_ZLIB_HEADER 12
+
/*------------------------------------------------------------*/
/*--- 32/64-bit parameterisation ---*/
/*------------------------------------------------------------*/
# define ElfXX_Dyn Elf32_Dyn
# define ELFXX_ST_BIND ELF32_ST_BIND
# define ELFXX_ST_TYPE ELF32_ST_TYPE
+# define ElfXX_Chdr Elf32_Chdr
#elif VG_WORDSIZE == 8
# define ElfXX_Ehdr Elf64_Ehdr
# define ElfXX_Dyn Elf64_Dyn
# define ELFXX_ST_BIND ELF64_ST_BIND
# define ELFXX_ST_TYPE ELF64_ST_TYPE
+# define ElfXX_Chdr Elf64_Chdr
#else
# error "VG_WORDSIZE should be 4 or 8"
return 0;
}
+/* Check if section is compressed and modify DiSlice if it is.
+ Returns False in case of unsupported compression type.
+*/
+static Bool check_compression(ElfXX_Shdr* h, DiSlice* s) {
+ if (h->sh_flags & SHF_COMPRESSED) {
+ ElfXX_Chdr chdr;
+ ML_(img_get)(&chdr, s->img, s->ioff, sizeof(ElfXX_Chdr));
+ if (chdr.ch_type != ELFCOMPRESS_ZLIB)
+ return False;
+ s->ioff = ML_(img_mark_compressed_part)(s->img,
+ s->ioff + sizeof(ElfXX_Chdr),
+ s->szB - sizeof(ElfXX_Chdr),
+ (SizeT)chdr.ch_size);
+ s->szB = chdr.ch_size;
+ } else if (h->sh_size > SIZE_OF_ZLIB_HEADER) {
+ /* Read the zlib header. In this case, it should be "ZLIB"
+ followed by the uncompressed section size, 8 bytes in BE order. */
+ UChar tmp[SIZE_OF_ZLIB_HEADER];
+ ML_(img_get)(tmp, s->img, s->ioff, SIZE_OF_ZLIB_HEADER);
+ if (VG_(memcmp)(tmp, "ZLIB", 4) == 0) {
+ SizeT size;
+# if (VG_WORDSIZE == 8)
+ size = tmp[4]; size <<= 8;
+ size += tmp[5]; size <<= 8;
+ size += tmp[6]; size <<= 8;
+ size += tmp[7]; size <<= 8;
+# else
+ vg_assert((tmp[4] == 0) && (tmp[5] == 0) && (tmp[6] == 0)
+ && (tmp[7] == 0));
+ size = 0;
+# endif
+ size += tmp[8]; size <<= 8;
+ size += tmp[9]; size <<= 8;
+ size += tmp[10]; size <<= 8;
+ size += tmp[11];
+ s->ioff = ML_(img_mark_compressed_part)(s->img,
+ s->ioff + SIZE_OF_ZLIB_HEADER,
+ s->szB - SIZE_OF_ZLIB_HEADER,
+ size);
+ s->szB = size;
+ }
+ }
+ return True;
+}
/* The central function for reading ELF debug info. For the
object/exe specified by the DebugInfo, find ELF sections, then read
_sec_escn.img = mimg; \
_sec_escn.ioff = (DiOffT)a_shdr.sh_offset; \
_sec_escn.szB = a_shdr.sh_size; \
+ if (!check_compression(&a_shdr, &_sec_escn)) { \
+ ML_(symerr)(di, True, " Compression type is unsupported"); \
+ goto out; \
+ } \
nobits = a_shdr.sh_type == SHT_NOBITS; \
vg_assert(_sec_escn.img != NULL); \
vg_assert(_sec_escn.ioff != DiOffT_INVALID); \
TRACE_SYMTAB( "%-18s: ioff %llu .. %llu\n", \
- _sec_name, (ULong)_sec_escn.ioff, \
- ((ULong)_sec_escn.ioff) + _sec_escn.szB - 1); \
+ _sec_name, (ULong)a_shdr.sh_offset, \
+ ((ULong)a_shdr.sh_offset) + a_shdr.sh_size - 1); \
/* SHT_NOBITS sections have zero size in the file. */ \
if (!nobits && \
- a_shdr.sh_offset + _sec_escn.szB > ML_(img_size)(mimg) ) { \
+ a_shdr.sh_offset + \
+ a_shdr.sh_size > ML_(img_real_size)(mimg)) { \
ML_(symerr)(di, True, \
" section beyond image end?!"); \
goto out; \
# define FIND(_sec_name, _sec_escn) \
FINDX(_sec_name, _sec_escn, /**/)
- /* NAME ElfSec */
- FIND(".dynsym", dynsym_escn)
- FIND(".dynstr", dynstr_escn)
- FIND(".symtab", symtab_escn)
- FIND(".strtab", strtab_escn)
+ /* NAME ElfSec */
+ FIND( ".dynsym", dynsym_escn)
+ FIND( ".dynstr", dynstr_escn)
+ FIND( ".symtab", symtab_escn)
+ FIND( ".strtab", strtab_escn)
# if defined(VGO_solaris)
- FIND(".SUNW_ldynsym", ldynsym_escn)
+ FIND( ".SUNW_ldynsym", ldynsym_escn)
# endif
- FIND(".gnu_debuglink", debuglink_escn)
- FIND(".gnu_debugaltlink", debugaltlink_escn)
+ FIND( ".gnu_debuglink", debuglink_escn)
+ FIND( ".gnu_debugaltlink", debugaltlink_escn)
+
+ FIND( ".debug_line", debug_line_escn)
+ if (!ML_(sli_is_valid)(debug_line_escn))
+ FIND(".zdebug_line", debug_line_escn)
+
+ FIND( ".debug_info", debug_info_escn)
+ if (!ML_(sli_is_valid)(debug_info_escn))
+ FIND(".zdebug_info", debug_info_escn)
+
+ FIND( ".debug_types", debug_types_escn)
+ if (!ML_(sli_is_valid)(debug_types_escn))
+ FIND(".zdebug_types", debug_types_escn)
- FIND(".debug_line", debug_line_escn)
- FIND(".debug_info", debug_info_escn)
- FIND(".debug_types", debug_types_escn)
- FIND(".debug_abbrev", debug_abbv_escn)
- FIND(".debug_str", debug_str_escn)
- FIND(".debug_ranges", debug_ranges_escn)
- FIND(".debug_loc", debug_loc_escn)
- FIND(".debug_frame", debug_frame_escn)
+ FIND( ".debug_abbrev", debug_abbv_escn)
+ if (!ML_(sli_is_valid)(debug_abbv_escn))
+ FIND(".zdebug_abbrev", debug_abbv_escn)
- FIND(".debug", dwarf1d_escn)
- FIND(".line", dwarf1l_escn)
+ FIND( ".debug_str", debug_str_escn)
+ if (!ML_(sli_is_valid)(debug_str_escn))
+ FIND(".zdebug_str", debug_str_escn)
- FIND(".opd", opd_escn)
+ FIND( ".debug_ranges", debug_ranges_escn)
+ if (!ML_(sli_is_valid)(debug_ranges_escn))
+ FIND(".zdebug_ranges", debug_ranges_escn)
- FINDX(".eh_frame", ehframe_escn[ehframe_mix],
+ FIND( ".debug_loc", debug_loc_escn)
+ if (!ML_(sli_is_valid)(debug_loc_escn))
+ FIND(".zdebug_loc", debug_loc_escn)
+
+ FIND( ".debug_frame", debug_frame_escn)
+ if (!ML_(sli_is_valid)(debug_frame_escn))
+ FIND(".zdebug_frame", debug_frame_escn)
+
+ FIND( ".debug", dwarf1d_escn)
+ FIND( ".line", dwarf1l_escn)
+
+ FIND( ".opd", opd_escn)
+
+ FINDX( ".eh_frame", ehframe_escn[ehframe_mix],
do { ehframe_mix++; vg_assert(ehframe_mix <= N_EHFRAME_SECTS);
} while (0)
)
_sec_escn.img = dimg; \
_sec_escn.ioff = (DiOffT)a_shdr.sh_offset; \
_sec_escn.szB = a_shdr.sh_size; \
+ if (!check_compression(&a_shdr, &_sec_escn)) { \
+ ML_(symerr)(di, True, " Compression type is unsupported"); \
+ goto out; \
+ } \
nobits = a_shdr.sh_type == SHT_NOBITS; \
vg_assert(_sec_escn.img != NULL); \
vg_assert(_sec_escn.ioff != DiOffT_INVALID); \
TRACE_SYMTAB( "%-18s: dioff %llu .. %llu\n", \
_sec_name, \
- (ULong)_sec_escn.ioff, \
- ((ULong)_sec_escn.ioff) + _sec_escn.szB - 1); \
+ (ULong)a_shdr.sh_offset, \
+ ((ULong)a_shdr.sh_offset) + a_shdr.sh_size - 1); \
/* SHT_NOBITS sections have zero size in the file. */ \
if (!nobits && a_shdr.sh_offset \
- + _sec_escn.szB > ML_(img_size)(dimg)) { \
+ + a_shdr.sh_size > ML_(img_real_size)(_sec_escn.img)) { \
ML_(symerr)(di, True, \
" section beyond image end?!"); \
goto out; \
} \
} while (0);
- /* NEEDED? NAME ElfSec */
- FIND(need_symtab, ".symtab", symtab_escn)
- FIND(need_symtab, ".strtab", strtab_escn)
- FIND(need_dwarf2, ".debug_line", debug_line_escn)
- FIND(need_dwarf2, ".debug_info", debug_info_escn)
- FIND(need_dwarf2, ".debug_types", debug_types_escn)
+ /* NEEDED? NAME ElfSec */
+ FIND( need_symtab, ".symtab", symtab_escn)
+ FIND( need_symtab, ".strtab", strtab_escn)
+ FIND( need_dwarf2, ".debug_line", debug_line_escn)
+ if (!ML_(sli_is_valid)(debug_line_escn))
+ FIND(need_dwarf2, ".zdebug_line", debug_line_escn)
+
+ FIND( need_dwarf2, ".debug_info", debug_info_escn)
+ if (!ML_(sli_is_valid)(debug_info_escn))
+ FIND(need_dwarf2, ".zdebug_info", debug_info_escn)
+
+ FIND( need_dwarf2, ".debug_types", debug_types_escn)
+ if (!ML_(sli_is_valid)(debug_types_escn))
+ FIND(need_dwarf2, ".zdebug_types", debug_types_escn)
- FIND(need_dwarf2, ".debug_abbrev", debug_abbv_escn)
- FIND(need_dwarf2, ".debug_str", debug_str_escn)
- FIND(need_dwarf2, ".debug_ranges", debug_ranges_escn)
+ FIND( need_dwarf2, ".debug_abbrev", debug_abbv_escn)
+ if (!ML_(sli_is_valid)(debug_abbv_escn))
+ FIND(need_dwarf2, ".zdebug_abbrev", debug_abbv_escn)
- FIND(need_dwarf2, ".debug_loc", debug_loc_escn)
- FIND(need_dwarf2, ".debug_frame", debug_frame_escn)
+ FIND( need_dwarf2, ".debug_str", debug_str_escn)
+ if (!ML_(sli_is_valid)(debug_str_escn))
+ FIND(need_dwarf2, ".zdebug_str", debug_str_escn)
- FIND(need_dwarf2, ".gnu_debugaltlink", debugaltlink_escn)
+ FIND( need_dwarf2, ".debug_ranges", debug_ranges_escn)
+ if (!ML_(sli_is_valid)(debug_ranges_escn))
+ FIND(need_dwarf2, ".zdebug_ranges", debug_ranges_escn)
- FIND(need_dwarf1, ".debug", dwarf1d_escn)
- FIND(need_dwarf1, ".line", dwarf1l_escn)
+ FIND( need_dwarf2, ".debug_loc", debug_loc_escn)
+ if (!ML_(sli_is_valid)(debug_loc_escn))
+ FIND(need_dwarf2, ".zdebug_loc", debug_loc_escn)
+
+ FIND( need_dwarf2, ".debug_frame", debug_frame_escn)
+ if (!ML_(sli_is_valid)(debug_frame_escn))
+ FIND(need_dwarf2, ".zdebug_frame", debug_frame_escn)
+
+ FIND( need_dwarf2, ".gnu_debugaltlink", debugaltlink_escn)
+
+ FIND( need_dwarf1, ".debug", dwarf1d_escn)
+ FIND( need_dwarf1, ".line", dwarf1l_escn)
# undef FIND
} /* Find all interesting sections */
_sec_escn.img = aimg; \
_sec_escn.ioff = (DiOffT)a_shdr.sh_offset; \
_sec_escn.szB = a_shdr.sh_size; \
+ if (!check_compression(&a_shdr, &_sec_escn)) { \
+ ML_(symerr)(di, True, " Compression type is " \
+ "unsupported"); \
+ goto out; \
+ } \
vg_assert(_sec_escn.img != NULL); \
vg_assert(_sec_escn.ioff != DiOffT_INVALID); \
TRACE_SYMTAB( "%-18s: aioff %llu .. %llu\n", \
_sec_name, \
- (ULong)_sec_escn.ioff, \
- ((ULong)_sec_escn.ioff) + _sec_escn.szB - 1); \
+ (ULong)a_shdr.sh_offset, \
+ ((ULong)a_shdr.sh_offset) + a_shdr.sh_size - 1); \
} \
} while (0);
- /* NAME ElfSec */
- FIND(".debug_line", debug_line_alt_escn)
- FIND(".debug_info", debug_info_alt_escn)
- FIND(".debug_abbrev", debug_abbv_alt_escn)
- FIND(".debug_str", debug_str_alt_escn)
+ /* NAME ElfSec */
+ FIND(".debug_line", debug_line_alt_escn)
+ if (!ML_(sli_is_valid)(debug_line_alt_escn))
+ FIND(".zdebug_line", debug_line_alt_escn)
+
+ FIND(".debug_info", debug_info_alt_escn)
+ if (!ML_(sli_is_valid)(debug_info_alt_escn))
+ FIND(".zdebug_info", debug_info_alt_escn)
+
+ FIND(".debug_abbrev", debug_abbv_alt_escn)
+ if (!ML_(sli_is_valid)(debug_abbv_alt_escn))
+ FIND(".zdebug_abbrev", debug_abbv_alt_escn)
+
+ FIND(".debug_str", debug_str_alt_escn)
+ if (!ML_(sli_is_valid)(debug_str_alt_escn))
+ FIND(".zdebug_str", debug_str_alt_escn)
# undef FIND
} /* Find all interesting sections */
--- /dev/null
+/*--------------------------------------------------------------------*/
+/*--- Tiny zlib decompressor tinfl.c ---*/
+/*--------------------------------------------------------------------*/
+
+/* tinfl.c v1.11 - public domain inflate with zlib header parsing/adler32
+ checking (inflate-only subset of miniz.c)
+
+ Rich Geldreich <richgel99@gmail.com>, last updated May 20, 2011
+
+ Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt
+ and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt
+
+ The original file has been modified in order to be a part of Valgrind
+ project, a dynamic binary instrumentation framework.
+ RT-RK Institute for Computer Based Systems, 2016 (mips-valgrind@rt-rk.com)
+
+ 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 of the
+ License, 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; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+*/
+
+#ifndef TINFL_HEADER_INCLUDED
+#define TINFL_HEADER_INCLUDED
+
+/* The entire decompressor coroutine is implemented in tinfl_decompress().
+ The other functions are optional high-level helpers. */
+
+#include "pub_core_basics.h"
+
+typedef UChar mz_uint8;
+typedef Short mz_int16;
+typedef UShort mz_uint16;
+typedef UInt mz_uint32;
+typedef UInt mz_uint;
+typedef ULong mz_uint64;
+
+#if defined(VGA_x86) || defined(VGA_amd64)
+// Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 if integer loads and stores to
+// unaligned addresses are acceptable on the target platform (slightly faster).
+#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
+#endif
+
+#define MINIZ_LITTLE_ENDIAN ( defined(VG_LITTLEENDIAN) )
+#define MINIZ_HAS_64BIT_REGISTERS ( VG_WORDSIZE == 8 )
+
+// Works around MSVC's spammy "warning C4127: conditional expression is
+// constant" message.
+#ifdef _MSC_VER
+ #define MZ_MACRO_END while (0, 0)
+#else
+ #define MZ_MACRO_END while (0)
+#endif
+
+/* Decompression flags used by tinfl_decompress().
+
+ TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and
+ ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the
+ input is a raw deflate stream.
+
+ TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available
+ beyond the end of the supplied input buffer. If clear, the input buffer
+ contains all remaining input.
+
+ TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large
+ enough to hold the entire decompressed stream. If clear, the output buffer
+ is at least the size of the dictionary (typically 32KB).
+
+ TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the
+ decompressed bytes.
+*/
+
+enum
+{
+ TINFL_FLAG_PARSE_ZLIB_HEADER = 1,
+ TINFL_FLAG_HAS_MORE_INPUT = 2,
+ TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4,
+ TINFL_FLAG_COMPUTE_ADLER32 = 8
+};
+
+// High level decompression functions:
+// tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block allocated via malloc().
+// On entry:
+// pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data to decompress.
+// On return:
+// Function returns a pointer to the decompressed data, or NULL on failure.
+// *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data.
+// The caller must free() the returned block when it's no longer needed.
+void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, SizeT src_buf_len, SizeT *pOut_len, int flags);
+
+// tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory.
+// Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success.
+#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((SizeT)(-1))
+SizeT tinfl_decompress_mem_to_mem(void *pOut_buf, SizeT out_buf_len, const void *pSrc_buf, SizeT src_buf_len, int flags);
+
+// tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer.
+// Returns 1 on success or 0 on failure.
+typedef int (*tinfl_put_buf_func_ptr)(const void* pBuf, int len, void *pUser);
+int tinfl_decompress_mem_to_callback(const void *pIn_buf, SizeT *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
+
+struct tinfl_decompressor_tag; typedef struct tinfl_decompressor_tag tinfl_decompressor;
+
+// Max size of LZ dictionary.
+#define TINFL_LZ_DICT_SIZE 32768
+
+// Return status.
+typedef enum
+{
+ TINFL_STATUS_BAD_PARAM = -3,
+ TINFL_STATUS_ADLER32_MISMATCH = -2,
+ TINFL_STATUS_FAILED = -1,
+ TINFL_STATUS_DONE = 0,
+ TINFL_STATUS_NEEDS_MORE_INPUT = 1,
+ TINFL_STATUS_HAS_MORE_OUTPUT = 2
+} tinfl_status;
+
+// Initializes the decompressor to its initial state.
+#define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END
+#define tinfl_get_adler32(r) (r)->m_check_adler32
+
+// Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability.
+// This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output.
+tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, SizeT *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, SizeT *pOut_buf_size, const mz_uint32 decomp_flags);
+
+// Internal/private bits follow.
+enum
+{
+ TINFL_MAX_HUFF_TABLES = 3, TINFL_MAX_HUFF_SYMBOLS_0 = 288, TINFL_MAX_HUFF_SYMBOLS_1 = 32, TINFL_MAX_HUFF_SYMBOLS_2 = 19,
+ TINFL_FAST_LOOKUP_BITS = 10, TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
+};
+
+typedef struct
+{
+ mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0];
+ mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
+} tinfl_huff_table;
+
+#if MINIZ_HAS_64BIT_REGISTERS
+ #define TINFL_USE_64BIT_BITBUF 1
+#endif
+
+#if TINFL_USE_64BIT_BITBUF
+ typedef mz_uint64 tinfl_bit_buf_t;
+ #define TINFL_BITBUF_SIZE (64)
+#else
+ typedef mz_uint32 tinfl_bit_buf_t;
+ #define TINFL_BITBUF_SIZE (32)
+#endif
+
+struct tinfl_decompressor_tag
+{
+ mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
+ tinfl_bit_buf_t m_bit_buf;
+ SizeT m_dist_from_out_buf_start;
+ tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES];
+ mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137];
+};
+
+#endif // #ifdef TINFL_HEADER_INCLUDED
+
+// ------------------- End of Header: Implementation follows. (If you only want the header, define MINIZ_HEADER_FILE_ONLY.)
+
+#ifndef TINFL_HEADER_FILE_ONLY
+
+#include "pub_core_mallocfree.h"
+#include "pub_core_libcbase.h"
+
+#define MZ_MAX(a,b) (((a)>(b))?(a):(b))
+#define MZ_MIN(a,b) (((a)<(b))?(a):(b))
+#define MZ_CLEAR_OBJ(obj) VG_(memset)(&(obj), 0, sizeof(obj))
+
+#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
+ #define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
+ #define MZ_READ_LE32(p) *((const mz_uint32 *)(p))
+#else
+ #define MZ_READ_LE16(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
+ #define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
+#endif
+
+#define TINFL_MEMCPY(d, s, l) VG_(memcpy)(d, s, l)
+#define TINFL_MEMSET(p, c, l) VG_(memset)(p, c, l)
+
+#define TINFL_CR_BEGIN switch(r->m_state) { case 0:
+#define TINFL_CR_RETURN(state_index, result) do { status = result; r->m_state = state_index; goto common_exit; case state_index:; } MZ_MACRO_END
+#define TINFL_CR_RETURN_FOREVER(state_index, result) do { for ( ; ; ) { TINFL_CR_RETURN(state_index, result); } } MZ_MACRO_END
+#define TINFL_CR_FINISH }
+
+// TODO: If the caller has indicated that there's no more input, and we attempt to read beyond the input buf, then something is wrong with the input because the inflator never
+// reads ahead more than it needs to. Currently TINFL_GET_BYTE() pads the end of the stream with 0's in this scenario.
+#define TINFL_GET_BYTE(state_index, c) do { \
+ if (pIn_buf_cur >= pIn_buf_end) { \
+ for ( ; ; ) { \
+ if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) { \
+ TINFL_CR_RETURN(state_index, TINFL_STATUS_NEEDS_MORE_INPUT); \
+ if (pIn_buf_cur < pIn_buf_end) { \
+ c = *pIn_buf_cur++; \
+ break; \
+ } \
+ } else { \
+ c = 0; \
+ break; \
+ } \
+ } \
+ } else c = *pIn_buf_cur++; } MZ_MACRO_END
+
+#define TINFL_NEED_BITS(state_index, n) do { mz_uint c; TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; } while (num_bits < (mz_uint)(n))
+#define TINFL_SKIP_BITS(state_index, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
+#define TINFL_GET_BITS(state_index, b, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } b = bit_buf & ((1 << (n)) - 1); bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END
+
+// TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2.
+// It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a
+// Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the
+// bit buffer contains >=15 bits (deflate's max. Huffman code size).
+#define TINFL_HUFF_BITBUF_FILL(state_index, pHuff) \
+ do { \
+ temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
+ if (temp >= 0) { \
+ code_len = temp >> 9; \
+ if ((code_len) && (num_bits >= code_len)) \
+ break; \
+ } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \
+ code_len = TINFL_FAST_LOOKUP_BITS; \
+ do { \
+ temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \
+ } while ((temp < 0) && (num_bits >= (code_len + 1))); if (temp >= 0) break; \
+ } TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; \
+ } while (num_bits < 15);
+
+// TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex than you would initially expect because the zlib API expects the decompressor to never read
+// beyond the final byte of the deflate stream. (In other words, when this macro wants to read another byte from the input, it REALLY needs another byte in order to fully
+// decode the next Huffman code.) Handling this properly is particularly important on raw deflate (non-zlib) streams, which aren't followed by a byte aligned adler-32.
+// The slow path is only executed at the very end of the input buffer.
+#define TINFL_HUFF_DECODE(state_index, sym, pHuff) do { \
+ int temp; mz_uint code_len, c; \
+ if (num_bits < 15) { \
+ if ((pIn_buf_end - pIn_buf_cur) < 2) { \
+ TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \
+ } else { \
+ bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); pIn_buf_cur += 2; num_bits += 16; \
+ } \
+ } \
+ if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \
+ code_len = temp >> 9, temp &= 511; \
+ else { \
+ code_len = TINFL_FAST_LOOKUP_BITS; do { temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; } while (temp < 0); \
+ } sym = temp; bit_buf >>= code_len; num_bits -= code_len; } MZ_MACRO_END
+
+tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, SizeT *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, SizeT *pOut_buf_size, const mz_uint32 decomp_flags)
+{
+ static const int s_length_base[31] = { 3,4,5,6,7,8,9,10,11,13, 15,17,19,23,27,31,35,43,51,59, 67,83,99,115,131,163,195,227,258,0,0 };
+ static const int s_length_extra[31]= { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+ static const int s_dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+ static const int s_dist_extra[32] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+ static const mz_uint8 s_length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+ static const int s_min_table_sizes[3] = { 257, 1, 4 };
+
+ tinfl_status status = TINFL_STATUS_FAILED; mz_uint32 num_bits, dist, counter, num_extra; tinfl_bit_buf_t bit_buf;
+ const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
+ mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next + *pOut_buf_size;
+ SizeT out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (SizeT)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start;
+
+ // Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter).
+ if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) { *pIn_buf_size = *pOut_buf_size = 0; return TINFL_STATUS_BAD_PARAM; }
+
+ num_bits = r->m_num_bits; bit_buf = r->m_bit_buf; dist = r->m_dist; counter = r->m_counter; num_extra = r->m_num_extra; dist_from_out_buf_start = r->m_dist_from_out_buf_start;
+ TINFL_CR_BEGIN
+
+ bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; r->m_z_adler32 = r->m_check_adler32 = 1;
+ if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
+ {
+ TINFL_GET_BYTE(1, r->m_zhdr0); TINFL_GET_BYTE(2, r->m_zhdr1);
+ counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
+ if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (SizeT)(1U << (8U + (r->m_zhdr0 >> 4)))));
+ if (counter) { TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); }
+ }
+
+ do
+ {
+ TINFL_GET_BITS(3, r->m_final, 3); r->m_type = r->m_final >> 1;
+ if (r->m_type == 0)
+ {
+ TINFL_SKIP_BITS(5, num_bits & 7);
+ for (counter = 0; counter < 4; ++counter) { if (num_bits) TINFL_GET_BITS(6, r->m_raw_header[counter], 8); else TINFL_GET_BYTE(7, r->m_raw_header[counter]); }
+ if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) { TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); }
+ while ((counter) && (num_bits))
+ {
+ TINFL_GET_BITS(51, dist, 8);
+ while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); }
+ *pOut_buf_cur++ = (mz_uint8)dist;
+ counter--;
+ }
+ while (counter)
+ {
+ SizeT n; while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); }
+ while (pIn_buf_cur >= pIn_buf_end)
+ {
+ if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)
+ {
+ TINFL_CR_RETURN(38, TINFL_STATUS_NEEDS_MORE_INPUT);
+ }
+ else
+ {
+ TINFL_CR_RETURN_FOREVER(40, TINFL_STATUS_FAILED);
+ }
+ }
+ n = MZ_MIN(MZ_MIN((SizeT)(pOut_buf_end - pOut_buf_cur), (SizeT)(pIn_buf_end - pIn_buf_cur)), counter);
+ TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); pIn_buf_cur += n; pOut_buf_cur += n; counter -= (mz_uint)n;
+ }
+ }
+ else if (r->m_type == 3)
+ {
+ TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
+ }
+ else
+ {
+ if (r->m_type == 1)
+ {
+ mz_uint8 *p = r->m_tables[0].m_code_size; mz_uint i;
+ r->m_table_sizes[0] = 288; r->m_table_sizes[1] = 32; TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32);
+ for ( i = 0; i <= 143; ++i) *p++ = 8; for ( ; i <= 255; ++i) *p++ = 9; for ( ; i <= 279; ++i) *p++ = 7; for ( ; i <= 287; ++i) *p++ = 8;
+ }
+ else
+ {
+ for (counter = 0; counter < 3; counter++) { TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); r->m_table_sizes[counter] += s_min_table_sizes[counter]; }
+ MZ_CLEAR_OBJ(r->m_tables[2].m_code_size); for (counter = 0; counter < r->m_table_sizes[2]; counter++) { mz_uint s; TINFL_GET_BITS(14, s, 3); r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s; }
+ r->m_table_sizes[2] = 19;
+ }
+ for ( ; (int)r->m_type >= 0; r->m_type--)
+ {
+ int tree_next, tree_cur; tinfl_huff_table *pTable;
+ mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; pTable = &r->m_tables[r->m_type]; MZ_CLEAR_OBJ(total_syms); MZ_CLEAR_OBJ(pTable->m_look_up); MZ_CLEAR_OBJ(pTable->m_tree);
+ for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) total_syms[pTable->m_code_size[i]]++;
+ used_syms = 0, total = 0; next_code[0] = next_code[1] = 0;
+ for (i = 1; i <= 15; ++i) { used_syms += total_syms[i]; next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); }
+ if ((65536 != total) && (used_syms > 1))
+ {
+ TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
+ }
+ for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
+ {
+ mz_uint rev_code = 0, l, cur_code, code_size = pTable->m_code_size[sym_index]; if (!code_size) continue;
+ cur_code = next_code[code_size]++; for (l = code_size; l > 0; l--, cur_code >>= 1) rev_code = (rev_code << 1) | (cur_code & 1);
+ if (code_size <= TINFL_FAST_LOOKUP_BITS) { mz_int16 k = (mz_int16)((code_size << 9) | sym_index); while (rev_code < TINFL_FAST_LOOKUP_SIZE) { pTable->m_look_up[rev_code] = k; rev_code += (1 << code_size); } continue; }
+ if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) { pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; }
+ rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
+ for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
+ {
+ tree_cur -= ((rev_code >>= 1) & 1);
+ if (!pTable->m_tree[-tree_cur - 1]) { pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; } else tree_cur = pTable->m_tree[-tree_cur - 1];
+ }
+ tree_cur -= ((rev_code >>= 1) & 1); pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index;
+ }
+ if (r->m_type == 2)
+ {
+ for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]); )
+ {
+ mz_uint s; TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]); if (dist < 16) { r->m_len_codes[counter++] = (mz_uint8)dist; continue; }
+ if ((dist == 16) && (!counter))
+ {
+ TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
+ }
+ num_extra = "\02\03\07"[dist - 16]; TINFL_GET_BITS(18, s, num_extra); s += "\03\03\013"[dist - 16];
+ TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); counter += s;
+ }
+ if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
+ {
+ TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
+ }
+ TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, r->m_table_sizes[0]); TINFL_MEMCPY(r->m_tables[1].m_code_size, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]);
+ }
+ }
+ for ( ; ; )
+ {
+ mz_uint8 *pSrc;
+ for ( ; ; )
+ {
+ if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
+ {
+ TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]);
+ if (counter >= 256)
+ break;
+ while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); }
+ *pOut_buf_cur++ = (mz_uint8)counter;
+ }
+ else
+ {
+ int sym2; mz_uint code_len;
+#if TINFL_USE_64BIT_BITBUF
+ if (num_bits < 30) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); pIn_buf_cur += 4; num_bits += 32; }
+#else
+ if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; }
+#endif
+ if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
+ code_len = sym2 >> 9;
+ else
+ {
+ code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0);
+ }
+ counter = sym2; bit_buf >>= code_len; num_bits -= code_len;
+ if (counter & 256)
+ break;
+
+#if !TINFL_USE_64BIT_BITBUF
+ if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; }
+#endif
+ if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
+ code_len = sym2 >> 9;
+ else
+ {
+ code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0);
+ }
+ bit_buf >>= code_len; num_bits -= code_len;
+
+ pOut_buf_cur[0] = (mz_uint8)counter;
+ if (sym2 & 256)
+ {
+ pOut_buf_cur++;
+ counter = sym2;
+ break;
+ }
+ pOut_buf_cur[1] = (mz_uint8)sym2;
+ pOut_buf_cur += 2;
+ }
+ }
+ if ((counter &= 511) == 256) break;
+
+ num_extra = s_length_extra[counter - 257]; counter = s_length_base[counter - 257];
+ if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(25, extra_bits, num_extra); counter += extra_bits; }
+
+ TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]);
+ num_extra = s_dist_extra[dist]; dist = s_dist_base[dist];
+ if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(27, extra_bits, num_extra); dist += extra_bits; }
+
+ dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
+ if ((dist > dist_from_out_buf_start) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
+ {
+ TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
+ }
+
+ pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
+
+ if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
+ {
+ while (counter--)
+ {
+ while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); }
+ *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
+ }
+ continue;
+ }
+#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
+ else if ((counter >= 9) && (counter <= dist))
+ {
+ const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
+ do
+ {
+ ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
+ ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
+ pOut_buf_cur += 8;
+ } while ((pSrc += 8) < pSrc_end);
+ if ((counter &= 7) < 3)
+ {
+ if (counter)
+ {
+ pOut_buf_cur[0] = pSrc[0];
+ if (counter > 1)
+ pOut_buf_cur[1] = pSrc[1];
+ pOut_buf_cur += counter;
+ }
+ continue;
+ }
+ }
+#endif
+ do
+ {
+ pOut_buf_cur[0] = pSrc[0];
+ pOut_buf_cur[1] = pSrc[1];
+ pOut_buf_cur[2] = pSrc[2];
+ pOut_buf_cur += 3; pSrc += 3;
+ } while ((int)(counter -= 3) > 2);
+ if ((int)counter > 0)
+ {
+ pOut_buf_cur[0] = pSrc[0];
+ if ((int)counter > 1)
+ pOut_buf_cur[1] = pSrc[1];
+ pOut_buf_cur += counter;
+ }
+ }
+ }
+ } while (!(r->m_final & 1));
+ if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
+ {
+ TINFL_SKIP_BITS(32, num_bits & 7); for (counter = 0; counter < 4; ++counter) { mz_uint s; if (num_bits) TINFL_GET_BITS(41, s, 8); else TINFL_GET_BYTE(42, s); r->m_z_adler32 = (r->m_z_adler32 << 8) | s; }
+ }
+ TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
+ TINFL_CR_FINISH
+
+common_exit:
+ r->m_num_bits = num_bits; r->m_bit_buf = bit_buf; r->m_dist = dist; r->m_counter = counter; r->m_num_extra = num_extra; r->m_dist_from_out_buf_start = dist_from_out_buf_start;
+ *pIn_buf_size = pIn_buf_cur - pIn_buf_next; *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
+ if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
+ {
+ const mz_uint8 *ptr = pOut_buf_next; SizeT buf_len = *pOut_buf_size;
+ mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; SizeT block_len = buf_len % 5552;
+ while (buf_len)
+ {
+ for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
+ {
+ s1 += ptr[0], s2 += s1; s1 += ptr[1], s2 += s1; s1 += ptr[2], s2 += s1; s1 += ptr[3], s2 += s1;
+ s1 += ptr[4], s2 += s1; s1 += ptr[5], s2 += s1; s1 += ptr[6], s2 += s1; s1 += ptr[7], s2 += s1;
+ }
+ for ( ; i < block_len; ++i) s1 += *ptr++, s2 += s1;
+ s1 %= 65521U, s2 %= 65521U; buf_len -= block_len; block_len = 5552;
+ }
+ r->m_check_adler32 = (s2 << 16) + s1; if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) status = TINFL_STATUS_ADLER32_MISMATCH;
+ }
+ return status;
+}
+
+// Higher level helper functions.
+void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, SizeT src_buf_len, SizeT *pOut_len, int flags)
+{
+ tinfl_decompressor decomp; void *pBuf = NULL, *pNew_buf; SizeT src_buf_ofs = 0, out_buf_capacity = 0;
+ *pOut_len = 0;
+ tinfl_init(&decomp);
+ for ( ; ; )
+ {
+ SizeT src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
+ tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8*)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8*)pBuf, pBuf ? (mz_uint8*)pBuf + *pOut_len : NULL, &dst_buf_size,
+ (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
+ if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
+ {
+ VG_(free)(pBuf); *pOut_len = 0; return NULL;
+ }
+ src_buf_ofs += src_buf_size;
+ *pOut_len += dst_buf_size;
+ if (status == TINFL_STATUS_DONE) break;
+ new_out_buf_capacity = out_buf_capacity * 2; if (new_out_buf_capacity < 128) new_out_buf_capacity = 128;
+ pNew_buf = VG_(realloc)("tinfl.tinfl_decompress_mem_to_heap.1", pBuf, new_out_buf_capacity);
+ if (!pNew_buf)
+ {
+ VG_(free)(pBuf); *pOut_len = 0; return NULL;
+ }
+ pBuf = pNew_buf; out_buf_capacity = new_out_buf_capacity;
+ }
+ return pBuf;
+}
+
+SizeT tinfl_decompress_mem_to_mem(void *pOut_buf, SizeT out_buf_len, const void *pSrc_buf, SizeT src_buf_len, int flags)
+{
+ tinfl_decompressor decomp; tinfl_status status; tinfl_init(&decomp);
+ status = tinfl_decompress(&decomp, (const mz_uint8*)pSrc_buf, &src_buf_len, (mz_uint8*)pOut_buf, (mz_uint8*)pOut_buf, &out_buf_len, (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
+ return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
+}
+
+int tinfl_decompress_mem_to_callback(const void *pIn_buf, SizeT *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
+{
+ int result = 0;
+ tinfl_decompressor decomp;
+ mz_uint8 *pDict = (mz_uint8*)VG_(malloc)("tinfl.tinfl_decompress_mem_to_callback.1", TINFL_LZ_DICT_SIZE); SizeT in_buf_ofs = 0, dict_ofs = 0;
+ if (!pDict)
+ return TINFL_STATUS_FAILED;
+ tinfl_init(&decomp);
+ for ( ; ; )
+ {
+ SizeT in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
+ tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8*)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
+ (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
+ in_buf_ofs += in_buf_size;
+ if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
+ break;
+ if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
+ {
+ result = (status == TINFL_STATUS_DONE);
+ break;
+ }
+ dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
+ }
+ VG_(free)(pDict);
+ *pIn_buf_size = in_buf_ofs;
+ return result;
+}
+
+#endif // #ifndef TINFL_HEADER_FILE_ONLY
bug287260.stderr.exp bug287260.vgtest \
bug340392.stderr.exp bug340392.vgtest \
calloc-overflow.stderr.exp calloc-overflow.vgtest\
+ cdebug_zlib.stderr.exp cdebug_zlib.vgtest \
+ cdebug_zlib_gnu.stderr.exp cdebug_zlib_gnu.vgtest \
client-msg.stderr.exp client-msg.vgtest \
client-msg-as-xml.stderr.exp client-msg-as-xml.vgtest \
clientperm.stderr.exp \
check_PROGRAMS += dw4
endif
+if GZ_ZLIB
+check_PROGRAMS += cdebug_zlib
+cdebug_zlib_SOURCES = cdebug.c
+cdebug_zlib_CFLAGS = $(AM_CFLAGS) -g -gz=zlib @FLAG_W_NO_UNINITIALIZED@
+endif
+
+if GZ_ZLIB_GNU
+check_PROGRAMS += cdebug_zlib_gnu
+cdebug_zlib_gnu_SOURCES = cdebug.c
+cdebug_zlib_gnu_CFLAGS = $(AM_CFLAGS) -g -gz=zlib-gnu @FLAG_W_NO_UNINITIALIZED@
+endif
+
if HAVE_GNU_STPNCPY
check_PROGRAMS += stpncpy
endif
--- /dev/null
+int main() {
+ int x;
+ if (x) return 1;
+ return 0;
+}
--- /dev/null
+Conditional jump or move depends on uninitialised value(s)
+ at 0x........: main (cdebug.c:3)
+
--- /dev/null
+prog: cdebug_zlib
+prereq: test -e cdebug_zlib
+vgopts: -q
+stderr_filter: filter_stderr
+stderr_filter_args: cdebug.c
--- /dev/null
+Conditional jump or move depends on uninitialised value(s)
+ at 0x........: main (cdebug.c:3)
+
--- /dev/null
+prog: cdebug_zlib_gnu
+prereq: test -e cdebug_zlib_gnu
+vgopts: -q
+stderr_filter: filter_stderr
+stderr_filter_args: cdebug.c
projects / thirdparty / valgrind.git / commitdiff
