From: Julian Seward Date: Thu, 8 Aug 2013 10:56:08 +0000 (+0000) Subject: A comprehensive test case for 128 bit shadow vector loads in the case X-Git-Tag: svn/VALGRIND_3_9_0~202 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=9ae14ce8483437991e5bdb342938c838172c1a52;p=thirdparty%2Fvalgrind.git A comprehensive test case for 128 bit shadow vector loads in the case of partial addressibility, for --shadow-loads-ok=yes and =no. Not portable and not hooked up to the test/build system yet. Pertains to #294285. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@13489 --- diff --git a/memcheck/tests/sh-mem-vec.c b/memcheck/tests/sh-mem-vec.c new file mode 100644 index 0000000000..cb2e0440a5 --- /dev/null +++ b/memcheck/tests/sh-mem-vec.c @@ -0,0 +1,551 @@ + +// Tests shadow memory correctness for 16-byte vector loads/stores + +#include +#include +#include +#include +#include "tests/malloc.h" +#include "memcheck/memcheck.h" + +// What we're actually testing +static __attribute__((noinline)) +void vector16_copy ( void* dst, void* src ) +{ + __asm__ __volatile__( + "movups (%1), %%xmm7 ; movups %%xmm7, (%0)" + : /*OUT*/ : /*IN*/ "r"(dst), "r"(src) : "memory","xmm7" + ); +} + +// All the sizes here are in *bytes*, not bits. + +typedef unsigned char U1; +typedef unsigned short U2; +typedef unsigned int U4; +typedef unsigned long long U8; +typedef unsigned long int UWord; + +typedef unsigned char Bool; +#define True ((Bool)1) +#define False ((Bool)0) + +#define CFENCE __asm__ __volatile__("":::"cc","memory") + + +static inline U4 randomU4 ( void ) +{ + static U4 n = 0; + /* From "Numerical Recipes in C" 2nd Edition */ + n = 1664525UL * n + 1013904223UL; + return n; +} + +static inline U1 randomU1 ( void ) +{ + return 0xFF & (randomU4() >> 13); +} + +#define N_BYTES 80000 +#define N_EVENTS (N_BYTES * 2) + +// Return x, but with its definedness bits set to be its own value bits +static inline U1 self_shadow ( U1 x ) +{ + U1 res = 0xFF; + VALGRIND_MAKE_MEM_UNDEFINED(&res, 1); + res &= x; + return res; +} + +static inline U1 get_shadow ( U1 x ) +{ + U1 res = 0; + U4 r = VALGRIND_GET_VBITS(&x, &res, 1); + assert(r == 1 || r == 0); + return res; +} + +static inline U1 make_def ( U1 x ) +{ + U1 y = x; + VALGRIND_MAKE_MEM_DEFINED(&y, 1); + return y; +} + +static inline U1 make_undef ( U1 x ) +{ + U1 y = x; + VALGRIND_MAKE_MEM_UNDEFINED(&y, 1); + return y; +} + +static void make_noaccess ( U1* dst ) +{ + VALGRIND_MAKE_MEM_NOACCESS(dst, 1); +} + +static void apply ( void(*fn)(U4,Bool), U4 arg1, Bool arg2 ) +{ + switch (arg1 & (32-1)) { + case 0: CFENCE; fn(arg1, arg2); CFENCE; break; + case 1: CFENCE; fn(arg1, arg2); CFENCE; break; + case 2: CFENCE; fn(arg1, arg2); CFENCE; break; + case 3: CFENCE; fn(arg1, arg2); CFENCE; break; + case 4: CFENCE; fn(arg1, arg2); CFENCE; break; + case 5: CFENCE; fn(arg1, arg2); CFENCE; break; + case 6: CFENCE; fn(arg1, arg2); CFENCE; break; + case 7: CFENCE; fn(arg1, arg2); CFENCE; break; + case 8: CFENCE; fn(arg1, arg2); CFENCE; break; + case 9: CFENCE; fn(arg1, arg2); CFENCE; break; + case 10: CFENCE; fn(arg1, arg2); CFENCE; break; + case 11: CFENCE; fn(arg1, arg2); CFENCE; break; + case 12: CFENCE; fn(arg1, arg2); CFENCE; break; + case 13: CFENCE; fn(arg1, arg2); CFENCE; break; + case 14: CFENCE; fn(arg1, arg2); CFENCE; break; + case 15: CFENCE; fn(arg1, arg2); CFENCE; break; + case 16: CFENCE; fn(arg1, arg2); CFENCE; break; + case 17: CFENCE; fn(arg1, arg2); CFENCE; break; + case 18: CFENCE; fn(arg1, arg2); CFENCE; break; + case 19: CFENCE; fn(arg1, arg2); CFENCE; break; + case 20: CFENCE; fn(arg1, arg2); CFENCE; break; + case 21: CFENCE; fn(arg1, arg2); CFENCE; break; + case 22: CFENCE; fn(arg1, arg2); CFENCE; break; + case 23: CFENCE; fn(arg1, arg2); CFENCE; break; + case 24: CFENCE; fn(arg1, arg2); CFENCE; break; + case 25: CFENCE; fn(arg1, arg2); CFENCE; break; + case 26: CFENCE; fn(arg1, arg2); CFENCE; break; + case 27: CFENCE; fn(arg1, arg2); CFENCE; break; + case 28: CFENCE; fn(arg1, arg2); CFENCE; break; + case 29: CFENCE; fn(arg1, arg2); CFENCE; break; + case 30: CFENCE; fn(arg1, arg2); CFENCE; break; + case 31: CFENCE; fn(arg1, arg2); CFENCE; break; + default: CFENCE; fn(arg1, arg2); CFENCE; break; + } +} + + // Try doing some partial-loads-ok/not-ok testing. + /* Test cases: + - load, 16-aligned, all no-access + ==> addr err + - load, 16-aligned, 1 to 15 initial bytes accessible, + then at least one unaccessible byte, + then remaining bytes in any state. + ==> if PLO then no error, but returned V bits are undefined + for unaccessible bytes + else + error; and V bits are defined for unaccessible bytes + + All of the above, but non-16-aligned: + -- all return an addressing error + */ + +static void do_partial_load_case ( U4 nInitialValid, Bool aligned ) +{ + fprintf(stderr, + "------ PL %s case with %u leading acc+def bytes ------\n\n", + aligned ? "Aligned" : "Unaligned", nInitialValid); + + U1* block = memalign16(64); + U4 j; + for (j = 0; j < 64; j++) block[j] = 0; + + if (!aligned) block++; + + // Make the block have this pattern: + // block[0 .. i-1] accessible and defined + // block[i .. 15] repeating NOACCESS, UNDEF, DEF + // hence block[i], at the very least, is always NOACCESS + U4 i = nInitialValid; + for (j = i; j < 16; j++) { + switch ((j-i) % 3) { + case 0: make_noaccess(&block[j]); break; + case 1: block[j] = make_undef(block[j]); break; + case 2: /* already acc and def */ break; + } + } + + // Do the access, possibly generating an error, and show the + // resulting V bits + U1 dst[16]; + vector16_copy(&dst[0], block); + + U1 dst_vbits[16]; + U4 r = VALGRIND_GET_VBITS(&dst[0], &dst_vbits[0], 16); + assert(r == 1 || r == 0); + + fprintf(stderr, "\n"); + for (j = 0; j < 16; j++) { + fprintf(stderr, "%c", dst_vbits[j] == 0 ? 'd' + : dst_vbits[j] == 0xFF ? 'U' : '?'); + } + fprintf(stderr, "\n\n"); + + // Also let's use the resulting value, to check we get an undef + // error + U1 sum = 0; + for (j = 0; j < 16; j++) + sum ^= dst[j]; + + if (sum == 42) { + CFENCE; fprintf(stderr, "%s", ""); CFENCE; + } else { + CFENCE; fprintf(stderr, "%s", ""); CFENCE; + } + + fprintf(stderr, "\n"); + + if (!aligned) block--; + free(block); +} + +int main ( void ) +{ + U4 i; + U1* buf = memalign16(N_BYTES); + + // Fill |buf| with bytes, so that zero bits have a zero shadow + // (are defined) and one bits have a one shadow (are undefined) + for (i = 0; i < N_BYTES/2; i++) { + buf[i] = self_shadow( (i & (1<<5)) ? 0x00 : 0xFF ); + } + for ( ; i < N_BYTES; i++) { + buf[i] = self_shadow( randomU1() ); + } + + // Randomly copy the data around. Once every 8 srcs/dsts, force + // the src or dst to be aligned. Once every 64, force both to be + // aligned. So as to give the fast (aligned) paths some checking. + const U4 n_copies = N_EVENTS; + U4 n_d_aligned = 0; + U4 n_s_aligned = 0; + U4 n_both_aligned = 0; + U4 n_fails = 0; + + for (i = 0; i < n_copies; i++) { + U4 si = randomU4() % (N_BYTES-16); + U4 di = randomU4() % (N_BYTES-16); + if (0 == (randomU1() & 7)) si &= ~(16-1); + if (0 == (randomU1() & 7)) di &= ~(16-1); + if (0 == (randomU1() & 63)) { di &= ~(16-1); si &= ~(16-1); } + + void* dst = &buf[di]; + void* src = &buf[si]; + + if (0 == (((UWord)src) & (16-1))) n_s_aligned++; + if (0 == (((UWord)dst) & (16-1))) n_d_aligned++; + if (0 == (((UWord)src) & (16-1)) && 0 == (((UWord)dst) & (16-1))) + n_both_aligned++; + + vector16_copy(dst, src); + } + + U4 freq[256]; + for (i = 0; i < 256; i++) + freq[i] = 0; + + for (i = 0; i < N_BYTES; i++) { + //if (i > 0 && 0 == (i & 0x0F)) fprintf(stderr, "\n"); + U1 v_actual = make_def(buf[i]); + U1 v_shadow = get_shadow(buf[i]); + if (v_actual != v_shadow) n_fails++; + //fprintf(stderr, "%02x:%02x ", (U4)v_actual, (U4)v_shadow); + freq[(U4)v_actual]++; + } + + fprintf(stderr, "\n"); + U4 totFreq = 0; + for (i = 0; i < 256; i++) { + totFreq += freq[i]; + if (i > 0 && (0 == (i % 16))) fprintf(stderr, "\n"); + fprintf(stderr, "%5u ", freq[i]); + } + assert(totFreq == N_BYTES); + + fprintf(stderr, "\n\n"); + fprintf(stderr, "%u copies, %u d_aligned, %u s_aligned, %u both_aligned\n", + n_copies, n_d_aligned, n_s_aligned, n_both_aligned); + fprintf(stderr, "%u %s\n", n_fails, n_fails == 0 ? "failures" : "FAILURES"); + + // Check that we can detect underruns of the block. + fprintf(stderr, "\nExpect 2 x no error\n" ); + vector16_copy( &buf[100], &buf[0] ); + vector16_copy( &buf[0], &buf[100] ); + + fprintf(stderr, "\nExpect 2 x error\n\n" ); + vector16_copy( &buf[100], &buf[-1] ); // invalid rd + vector16_copy( &buf[-1], &buf[100] ); // invalid wr + + // and overruns .. + fprintf(stderr, "\nExpect 2 x no error\n" ); + vector16_copy( &buf[200], &buf[N_BYTES-16 + 0] ); + vector16_copy( &buf[N_BYTES-16 + 0], &buf[200] ); + + fprintf(stderr, "\nExpect 2 x error\n\n" ); + vector16_copy( &buf[200], &buf[N_BYTES-16 + 1] ); + vector16_copy( &buf[N_BYTES-16 + 1], &buf[200] ); + + free(buf); + fprintf(stderr, "\n"); + + for (i = 0; i < 16; i++) + apply( do_partial_load_case, i, True/*aligned*/ ); + + for (i = 0; i < 16; i++) + apply( do_partial_load_case, i, False/*not aligned*/ ); + + return 0; +} + +// This is a version of sh-mem.c that works with vector types. +// It's too difficult to roll that into the macro magic in +// sh-mem.c, hence the separate program. + +// This program is a thorough test of the LOADVn/STOREVn shadow memory +// operations. + +#include +#include +#include +#include +#include "memcheck/memcheck.h" + +#if defined(__APPLE__) && defined(__i386__) +# define PLAT_x86_darwin 1 +#elif defined(__APPLE__) && defined(__x86_64__) +# define PLAT_amd64_darwin 1 +#elif defined(__MINGW32__) || defined(__CYGWIN32__) \ + || (defined(_WIN32) && defined(_M_IX86)) +# define PLAT_x86_win32 1 +#elif defined(__linux__) && defined(__i386__) +# define PLAT_x86_linux 1 +#elif defined(__linux__) && defined(__x86_64__) +# define PLAT_amd64_linux 1 +#elif defined(__linux__) && defined(__powerpc__) && !defined(__powerpc64__) +# define PLAT_ppc32_linux 1 +#elif defined(__linux__) && defined(__powerpc__) && defined(__powerpc64__) +# define PLAT_ppc64_linux 1 +#elif defined(__linux__) && defined(__arm__) +# define PLAT_arm_linux 1 +#elif defined(__linux__) && defined(__s390__) && defined(__s390x__) +# define PLAT_s390x_linux 1 +#elif defined(__linux__) && defined(__mips__) && (__mips == 64) +# define PLAT_mips64_linux 1 +#elif defined(__linux__) && defined(__mips__) && !(__mips == 64) +# define PLAT_mips32_linux 1 +#endif + +// All the sizes here are in *bytes*, not bits. + +typedef unsigned char U1; +typedef unsigned short U2; +typedef unsigned int U4; +typedef unsigned long long U8; + +typedef float F4; +typedef double F8; + +typedef unsigned char V16 __attribute__((vector_size (16))); + +typedef unsigned char Bool; +#define False ((Bool)0) +#define True ((Bool)1) + +#define SZB_OF_a 128 + +// a[] is the array in which we do our loads and stores. +// b[] is another one in which we do some copying. +U8 a [SZB_OF_a / 8]; // Type is U8 to ensure it's 8-aligned +U8 b [SZB_OF_a / 8]; // same size as a[] + +// XXX: should check the error cases for SET/GET_VBITS also + +static Bool eq_V16 ( V16 x, V16 y ) { + return 0 == memcmp(&x, &y, sizeof(x)); +} + +__attribute__((noinline)) +static void copy_V16 ( volatile V16* dst, volatile V16* src ) +{ +# if defined(PLAT_amd64_linux) || defined(PLAT_amd64_darwin) + __asm__ __volatile__( "movupd (%0),%%xmm0 ; movupd %%xmm0,(%1)" + : : "r"(src), "r"(dst) : "memory","xmm0"); +# else + *dst = *src; +# endif +} + +// For the byte 'x', build a value of 'size' bytes from that byte, eg: +// size 1 --> x +// size 2 --> xx +// size 4 --> xxxx +// size 8 --> xxxxxxxx +// size 16 --> xxxxxxxx'xxxxxxxx +// where the 0 bits are seen by Memcheck as defined, and the 1 bits are +// seen as undefined (ie. the value of each bit matches its V bit, ie. the +// resulting value is the same as its metavalue). +// +V16 build(int size, U1 byte) +{ + int i; + V16 mask; memset(&mask, 0, sizeof(mask)); + V16 shres; + V16 res; memset(&res, 0xFF, sizeof(res)); + V16 res2; + VALGRIND_MAKE_MEM_UNDEFINED(&res, sizeof(res)); + assert(16 == size); + + for (i = 0; i < size; i++) { + mask <<= 8; + mask |= (U8)byte; + } + + res &= mask; + + // res is now considered partially defined, but we know exactly what its + // value is (it happens to be the same as its metavalue). + + (void)VALGRIND_GET_VBITS(&res, &shres, sizeof(res)); + res2 = res; + // avoid the 'undefined' warning + (void)VALGRIND_MAKE_MEM_DEFINED(&res2, sizeof(res2)); + assert(eq_V16(res2, shres)); + + return res; +} + +// Check that all the bytes in a[x..y-1] have their V byte equal +// to 'expected_byte''. +// 'str' and 'offset' are only used for printing an error message if +// something goes wrong. +void check_all(U4 x, U4 y, U1 expected_byte, + char* str, int offset) +{ + U1 sh[SZB_OF_a]; // Used for getting a[]'s V bits + int i; + assert(x < y); + assert(y <= SZB_OF_a); + assert(x < SZB_OF_a); + + (void)VALGRIND_GET_VBITS(a, sh, sizeof(a)); + for (i = x; i < y; i++) { + if ( expected_byte != sh[i] ) { + fprintf(stderr, "\n\nFAILURE: %s, offset %d, byte %d -- " + "is 0x%x, should be 0x%x\n\n", + str, offset, i, sh[i], expected_byte); + exit(1); + } + } +} + +int main(void) +{ + int h, i, j; + U1 *undefA, expected_byte; + + if (0 == RUNNING_ON_VALGRIND) { + fprintf(stderr, + "error: this program only works when run under Valgrind\n"); + exit(1); + } + + // Check a[] has the expected alignment, and that it's not too high in + // the address space (which would trigger the slow cases in + // LOADVn/STOREVn) on 64-bit platforms). + assert( 0 == (long)a % 8); + if (sizeof(void*) == 8) { + assert( ((U1*)(&a[0])) < ((U1*)(32ULL * 1024*1024*1024)/*32G*/) ); + } + + // Check basic types have the expected sizes. + assert(1 == sizeof(U1)); + assert(2 == sizeof(U2)); + assert(4 == sizeof(U4)); + assert(8 == sizeof(U8)); + assert(16 == sizeof(V16)); + + // Create an array of values that has all the possible V bit metavalues. + // Because 0 represents a defined bit, and because undefA[] is initially + // zeroed, we have the nice property that: + // + // i == undefA[i] == V_bits_of(undefA[i]) + // + // which is useful for testing below. + undefA = calloc(1, 256); // one for each possible undefinedness value + VALGRIND_MAKE_MEM_UNDEFINED(undefA, 256); + for (i = 0; i < 256; i++) { + undefA[i] &= i; + } + + // This code does a whole lot of reads and writes of a particular size + // (NNN = 16 or 32), with varying alignments, of values with + // different not/partially/fully defined metavalues, and checks that the + // V bits are set in a[] as expected using GET_VBITS. + // + // 'Ty' is the type of the thing we are copying. It can be an integer + // type or an FP type. 'ITy' is the same-sized integer type (and thus + // will be the same as 'Ty' if 'ITy' is an integer type). 'ITy' is used + // when doing shifting/masking and stuff like that. + +#define Ty V16 +#define NNN 16 +#define VEC_EQ eq_V16 + + fprintf(stderr, "-- NNN: %d %s ------------------------\n", + NNN, "V16"); + /* For all of the alignments from (0..NNN-1), eg. if NNN==16, we do */ + /* alignments of 0, 1, 2 .. 15. */ + for (h = 0; h < NNN; h++) { + + size_t n = sizeof(a); + size_t nN = n / sizeof(Ty); + volatile Ty* aN = (Ty*)a; + volatile Ty* bN = (Ty*)b; + volatile Ty* aNb = (Ty*)(((U1*)aN) + h); /* set offset from a[] */ + volatile Ty* bNb = (Ty*)(((U1*)bN) + h); /* set offset from b[] */ + + fprintf(stderr, "h = %d (checking %d..%d) ", h, h, (int)(n-NNN+h)); + + /* For each of the 256 possible V byte values... */ + for (j = 0; j < 256; j++) { + /* build the value for i (one of: i, ii, iiii, iiiiiiii) */ + V16 tmp = build(NNN, j); + Ty undefN_ITy = (Ty)tmp; + { /* This just checks that no overflow occurred when squeezing */ + /* the output of build() into a variable of type 'Ty'. */ + V16 tmpDef = tmp; + Ty undefN_ITyDef = undefN_ITy; + VALGRIND_MAKE_MEM_DEFINED(&tmpDef, 16 ); + VALGRIND_MAKE_MEM_DEFINED(&undefN_ITyDef, NNN); + assert(VEC_EQ(tmpDef, undefN_ITyDef)); + } + + /* We have to use an array for undefN_Ty -- because if we try to + * convert an integer type from build into an FP type with a + * straight cast -- eg "float f = (float)i" -- the value gets + * converted. With this pointer/array nonsense the exact bit + * pattern gets used as an FP value unchanged (that FP value is + * undoubtedly nonsense, but that's not a problem here). */ + Ty* undefN_Ty = (Ty*)&undefN_ITy; + if (0 == j % 32) fprintf(stderr, "%d...", j); /* progress meter */ + fflush(stderr); fflush(stdout); + + expected_byte = j; + + /* STOREVn. Note that we use the first element of the undefN_Ty + * array, as explained above. */ + for (i = 0; i < nN-1; i++) { copy_V16(&aNb[i], &undefN_Ty[0]); } + check_all(h, n-NNN+h, expected_byte, + "STOREVn", h); + + /* LOADVn -- by copying the values to one place and then back, + * we ensure that LOADVn gets exercised. */ + for (i = 0; i < nN-1; i++) { copy_V16(&bNb[i], &aNb[i]); } + for (i = 0; i < nN-1; i++) { copy_V16(&aNb[i], &bNb[i]); } + check_all(h, n-NNN+h, expected_byte, "LOADVn", h); + } + fprintf(stderr, "\n"); + } + + return 0; +} diff --git a/out-32-plo-no.txt b/out-32-plo-no.txt new file mode 100644 index 0000000000..1e31a7298d --- /dev/null +++ b/out-32-plo-no.txt @@ -0,0 +1,804 @@ +==31009== Memcheck, a memory error detector +==31009== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al. +==31009== Using Valgrind-3.9.0.SVN and LibVEX; rerun with -h for copyright info +==31009== Command: ./memcheck/tests/sh-mem-vec-32 +==31009== + +20537 136 171 75 38 63 139 23 5 110 66 421 194 86 232 115 + 56 198 303 65 285 137 309 203 147 37 179 137 65 181 379 118 + 91 235 54 135 110 40 362 74 146 108 159 174 313 106 292 271 + 183 65 277 34 250 172 283 111 141 30 26 15 184 93 79 99 + 75 89 153 157 9 113 189 58 90 31 81 79 133 132 61 113 + 282 15 119 12 57 361 14 250 93 116 226 215 229 275 186 126 + 209 371 84 74 93 159 286 179 84 112 60 137 116 117 394 217 + 77 133 197 265 72 43 280 26 604 47 194 171 199 411 123 112 + 281 26 47 64 236 89 223 86 68 125 47 391 18 171 124 110 + 59 135 143 240 73 242 72 59 345 20 46 415 77 87 34 125 + 152 85 107 117 334 183 8 131 63 70 27 238 6 181 71 108 + 242 542 53 94 50 86 181 173 141 125 33 75 409 38 109 70 + 52 179 48 94 212 60 330 150 147 26 462 307 88 171 85 76 + 108 108 296 253 152 124 196 227 116 12 606 61 197 120 94 269 + 121 38 37 167 138 92 172 234 138 67 96 19 346 10 56 241 + 142 130 85 495 65 176 87 140 46 124 70 100 78 142 270 22165 + +160000 copies, 30739 d_aligned, 30741 s_aligned, 7092 both_aligned +0 failures + +Expect 2 x no error + +Expect 2 x error + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x8048FFC: main (sh-mem-vec.c:276) +==31009== Address 0x403505f is 1 bytes before a block of size 80,000 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048ADB: main (sh-mem-vec.c:205) +==31009== +==31009== Invalid write of size 8 +==31009== at 0x804858F: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x8049005: main (sh-mem-vec.c:277) +==31009== Address 0x403505f is 1 bytes before a block of size 80,000 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048ADB: main (sh-mem-vec.c:205) +==31009== + +Expect 2 x no error + +Expect 2 x error + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804907C: main (sh-mem-vec.c:285) +==31009== Address 0x40488d1 is 79,985 bytes inside a block of size 80,000 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048ADB: main (sh-mem-vec.c:205) +==31009== +==31009== Invalid write of size 8 +==31009== at 0x804858F: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x8049085: main (sh-mem-vec.c:286) +==31009== Address 0x40488d9 is 79,993 bytes inside a block of size 80,000 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048ADB: main (sh-mem-vec.c:205) +==31009== + +------ PL Aligned case with 0 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485AE: apply (sh-mem-vec.c:91) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048950 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485AE: apply (sh-mem-vec.c:91) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dUddUddUddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485AE: apply (sh-mem-vec.c:91) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 1 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485BF: apply (sh-mem-vec.c:92) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048a00 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485BF: apply (sh-mem-vec.c:92) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +ddUddUddUddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485BF: apply (sh-mem-vec.c:92) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 2 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485D0: apply (sh-mem-vec.c:93) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048ab0 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485D0: apply (sh-mem-vec.c:93) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddUddUddUddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485D0: apply (sh-mem-vec.c:93) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 3 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485E1: apply (sh-mem-vec.c:94) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048b60 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485E1: apply (sh-mem-vec.c:94) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +ddddUddUddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485E1: apply (sh-mem-vec.c:94) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 4 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485F2: apply (sh-mem-vec.c:95) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048c10 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485F2: apply (sh-mem-vec.c:95) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddddUddUddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485F2: apply (sh-mem-vec.c:95) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 5 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048603: apply (sh-mem-vec.c:96) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048cc0 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048603: apply (sh-mem-vec.c:96) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +ddddddUddUddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048603: apply (sh-mem-vec.c:96) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 6 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048614: apply (sh-mem-vec.c:97) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048d70 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048614: apply (sh-mem-vec.c:97) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddddddUddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048614: apply (sh-mem-vec.c:97) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 7 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048625: apply (sh-mem-vec.c:98) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048e20 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048625: apply (sh-mem-vec.c:98) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +ddddddddUddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048625: apply (sh-mem-vec.c:98) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 8 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048636: apply (sh-mem-vec.c:99) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048ed0 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048636: apply (sh-mem-vec.c:99) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddddddddUddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048636: apply (sh-mem-vec.c:99) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 9 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048647: apply (sh-mem-vec.c:100) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4048f80 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048647: apply (sh-mem-vec.c:100) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +ddddddddddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048647: apply (sh-mem-vec.c:100) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 10 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048658: apply (sh-mem-vec.c:101) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4049030 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048658: apply (sh-mem-vec.c:101) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddddddddddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048658: apply (sh-mem-vec.c:101) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 11 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048669: apply (sh-mem-vec.c:102) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x40490e0 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048669: apply (sh-mem-vec.c:102) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +ddddddddddddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048669: apply (sh-mem-vec.c:102) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 12 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x804867A: apply (sh-mem-vec.c:103) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4049190 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x804867A: apply (sh-mem-vec.c:103) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddddddddddddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x804867A: apply (sh-mem-vec.c:103) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 13 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x804868B: apply (sh-mem-vec.c:104) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x4049240 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x804868B: apply (sh-mem-vec.c:104) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +ddddddddddddddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x804868B: apply (sh-mem-vec.c:104) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 14 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x804869C: apply (sh-mem-vec.c:105) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x40492f0 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x804869C: apply (sh-mem-vec.c:105) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddddddddddddddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x804869C: apply (sh-mem-vec.c:105) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +------ PL Aligned case with 15 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80486AD: apply (sh-mem-vec.c:106) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== Address 0x40493a0 is 0 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80486AD: apply (sh-mem-vec.c:106) +==31009== by 0x80490B8: main (sh-mem-vec.c:292) +==31009== + +dddddddddddddddd + + +------ PL Unaligned case with 0 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485AE: apply (sh-mem-vec.c:91) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049451 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485AE: apply (sh-mem-vec.c:91) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dUddUddUddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485AE: apply (sh-mem-vec.c:91) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 1 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485BF: apply (sh-mem-vec.c:92) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049501 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485BF: apply (sh-mem-vec.c:92) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +ddUddUddUddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485BF: apply (sh-mem-vec.c:92) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 2 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485D0: apply (sh-mem-vec.c:93) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x40495b1 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485D0: apply (sh-mem-vec.c:93) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddUddUddUddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485D0: apply (sh-mem-vec.c:93) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 3 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485E1: apply (sh-mem-vec.c:94) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049661 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485E1: apply (sh-mem-vec.c:94) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +ddddUddUddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485E1: apply (sh-mem-vec.c:94) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 4 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80485F2: apply (sh-mem-vec.c:95) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049711 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80485F2: apply (sh-mem-vec.c:95) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddddUddUddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x80485F2: apply (sh-mem-vec.c:95) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 5 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048603: apply (sh-mem-vec.c:96) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x40497c1 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048603: apply (sh-mem-vec.c:96) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +ddddddUddUddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048603: apply (sh-mem-vec.c:96) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 6 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048614: apply (sh-mem-vec.c:97) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049871 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048614: apply (sh-mem-vec.c:97) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddddddUddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048614: apply (sh-mem-vec.c:97) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 7 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048625: apply (sh-mem-vec.c:98) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049921 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048625: apply (sh-mem-vec.c:98) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +ddddddddUddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048625: apply (sh-mem-vec.c:98) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 8 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048636: apply (sh-mem-vec.c:99) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x40499d1 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048636: apply (sh-mem-vec.c:99) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddddddddUddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048636: apply (sh-mem-vec.c:99) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 9 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048647: apply (sh-mem-vec.c:100) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049a81 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048647: apply (sh-mem-vec.c:100) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +ddddddddddUddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048647: apply (sh-mem-vec.c:100) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 10 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048658: apply (sh-mem-vec.c:101) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049b31 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048658: apply (sh-mem-vec.c:101) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddddddddddUddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048658: apply (sh-mem-vec.c:101) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 11 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x8048669: apply (sh-mem-vec.c:102) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049be1 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x8048669: apply (sh-mem-vec.c:102) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +ddddddddddddUddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x8048669: apply (sh-mem-vec.c:102) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 12 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x804867A: apply (sh-mem-vec.c:103) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049c91 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x804867A: apply (sh-mem-vec.c:103) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddddddddddddUdd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x804867A: apply (sh-mem-vec.c:103) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 13 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x804868B: apply (sh-mem-vec.c:104) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049d41 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x804868B: apply (sh-mem-vec.c:104) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +ddddddddddddddUd + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x804868B: apply (sh-mem-vec.c:104) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 14 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x804869C: apply (sh-mem-vec.c:105) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049df1 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x804869C: apply (sh-mem-vec.c:105) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddddddddddddddU + +==31009== Conditional jump or move depends on uninitialised value(s) +==31009== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31009== by 0x804869C: apply (sh-mem-vec.c:105) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +------ PL Unaligned case with 15 leading acc+def bytes ------ + +==31009== Invalid read of size 16 +==31009== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31009== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31009== by 0x80486AD: apply (sh-mem-vec.c:106) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== Address 0x4049ea1 is 1 bytes inside a block of size 64 alloc'd +==31009== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31009== by 0x80487BA: memalign16 (malloc.h:21) +==31009== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31009== by 0x80486AD: apply (sh-mem-vec.c:106) +==31009== by 0x80490D3: main (sh-mem-vec.c:295) +==31009== + +dddddddddddddddd + + +==31009== +==31009== HEAP SUMMARY: +==31009== in use at exit: 0 bytes in 0 blocks +==31009== total heap usage: 33 allocs, 33 frees, 82,048 bytes allocated +==31009== +==31009== All heap blocks were freed -- no leaks are possible +==31009== +==31009== For counts of detected and suppressed errors, rerun with: -v +==31009== Use --track-origins=yes to see where uninitialised values come from +==31009== ERROR SUMMARY: 66 errors from 66 contexts (suppressed: 0 from 0) diff --git a/out-32-plo-yes.txt b/out-32-plo-yes.txt new file mode 100644 index 0000000000..92ef670791 --- /dev/null +++ b/out-32-plo-yes.txt @@ -0,0 +1,617 @@ +==31013== Memcheck, a memory error detector +==31013== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al. +==31013== Using Valgrind-3.9.0.SVN and LibVEX; rerun with -h for copyright info +==31013== Command: ./memcheck/tests/sh-mem-vec-32 +==31013== + +20537 136 171 75 38 63 139 23 5 110 66 421 194 86 232 115 + 56 198 303 65 285 137 309 203 147 37 179 137 65 181 379 118 + 91 235 54 135 110 40 362 74 146 108 159 174 313 106 292 271 + 183 65 277 34 250 172 283 111 141 30 26 15 184 93 79 99 + 75 89 153 157 9 113 189 58 90 31 81 79 133 132 61 113 + 282 15 119 12 57 361 14 250 93 116 226 215 229 275 186 126 + 209 371 84 74 93 159 286 179 84 112 60 137 116 117 394 217 + 77 133 197 265 72 43 280 26 604 47 194 171 199 411 123 112 + 281 26 47 64 236 89 223 86 68 125 47 391 18 171 124 110 + 59 135 143 240 73 242 72 59 345 20 46 415 77 87 34 125 + 152 85 107 117 334 183 8 131 63 70 27 238 6 181 71 108 + 242 542 53 94 50 86 181 173 141 125 33 75 409 38 109 70 + 52 179 48 94 212 60 330 150 147 26 462 307 88 171 85 76 + 108 108 296 253 152 124 196 227 116 12 606 61 197 120 94 269 + 121 38 37 167 138 92 172 234 138 67 96 19 346 10 56 241 + 142 130 85 495 65 176 87 140 46 124 70 100 78 142 270 22165 + +160000 copies, 30739 d_aligned, 30741 s_aligned, 7092 both_aligned +0 failures + +Expect 2 x no error + +Expect 2 x error + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x8048FFC: main (sh-mem-vec.c:276) +==31013== Address 0x403505f is 1 bytes before a block of size 80,000 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048ADB: main (sh-mem-vec.c:205) +==31013== +==31013== Invalid write of size 8 +==31013== at 0x804858F: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x8049005: main (sh-mem-vec.c:277) +==31013== Address 0x403505f is 1 bytes before a block of size 80,000 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048ADB: main (sh-mem-vec.c:205) +==31013== + +Expect 2 x no error + +Expect 2 x error + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804907C: main (sh-mem-vec.c:285) +==31013== Address 0x40488d1 is 79,985 bytes inside a block of size 80,000 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048ADB: main (sh-mem-vec.c:205) +==31013== +==31013== Invalid write of size 8 +==31013== at 0x804858F: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x8049085: main (sh-mem-vec.c:286) +==31013== Address 0x40488d9 is 79,993 bytes inside a block of size 80,000 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048ADB: main (sh-mem-vec.c:205) +==31013== + +------ PL Aligned case with 0 leading acc+def bytes ------ + + +UUdUUdUUdUUdUUdU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485AE: apply (sh-mem-vec.c:91) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 1 leading acc+def bytes ------ + + +dUUdUUdUUdUUdUUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485BF: apply (sh-mem-vec.c:92) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 2 leading acc+def bytes ------ + + +ddUUdUUdUUdUUdUU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485D0: apply (sh-mem-vec.c:93) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 3 leading acc+def bytes ------ + + +dddUUdUUdUUdUUdU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485E1: apply (sh-mem-vec.c:94) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 4 leading acc+def bytes ------ + + +ddddUUdUUdUUdUUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485F2: apply (sh-mem-vec.c:95) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 5 leading acc+def bytes ------ + + +dddddUUdUUdUUdUU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048603: apply (sh-mem-vec.c:96) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 6 leading acc+def bytes ------ + + +ddddddUUdUUdUUdU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048614: apply (sh-mem-vec.c:97) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 7 leading acc+def bytes ------ + + +dddddddUUdUUdUUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048625: apply (sh-mem-vec.c:98) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 8 leading acc+def bytes ------ + + +ddddddddUUdUUdUU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048636: apply (sh-mem-vec.c:99) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 9 leading acc+def bytes ------ + + +dddddddddUUdUUdU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048647: apply (sh-mem-vec.c:100) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 10 leading acc+def bytes ------ + + +ddddddddddUUdUUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048658: apply (sh-mem-vec.c:101) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 11 leading acc+def bytes ------ + + +dddddddddddUUdUU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048669: apply (sh-mem-vec.c:102) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 12 leading acc+def bytes ------ + + +ddddddddddddUUdU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x804867A: apply (sh-mem-vec.c:103) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 13 leading acc+def bytes ------ + + +dddddddddddddUUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x804868B: apply (sh-mem-vec.c:104) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 14 leading acc+def bytes ------ + + +ddddddddddddddUU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x804869C: apply (sh-mem-vec.c:105) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Aligned case with 15 leading acc+def bytes ------ + + +dddddddddddddddU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80486AD: apply (sh-mem-vec.c:106) +==31013== by 0x80490B8: main (sh-mem-vec.c:292) +==31013== + +------ PL Unaligned case with 0 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x80485AE: apply (sh-mem-vec.c:91) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049451 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x80485AE: apply (sh-mem-vec.c:91) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dUddUddUddUddUdd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485AE: apply (sh-mem-vec.c:91) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 1 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x80485BF: apply (sh-mem-vec.c:92) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049501 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x80485BF: apply (sh-mem-vec.c:92) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +ddUddUddUddUddUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485BF: apply (sh-mem-vec.c:92) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 2 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x80485D0: apply (sh-mem-vec.c:93) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x40495b1 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x80485D0: apply (sh-mem-vec.c:93) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddUddUddUddUddU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485D0: apply (sh-mem-vec.c:93) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 3 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x80485E1: apply (sh-mem-vec.c:94) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049661 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x80485E1: apply (sh-mem-vec.c:94) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +ddddUddUddUddUdd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485E1: apply (sh-mem-vec.c:94) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 4 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x80485F2: apply (sh-mem-vec.c:95) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049711 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x80485F2: apply (sh-mem-vec.c:95) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddddUddUddUddUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x80485F2: apply (sh-mem-vec.c:95) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 5 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x8048603: apply (sh-mem-vec.c:96) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x40497c1 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x8048603: apply (sh-mem-vec.c:96) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +ddddddUddUddUddU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048603: apply (sh-mem-vec.c:96) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 6 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x8048614: apply (sh-mem-vec.c:97) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049871 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x8048614: apply (sh-mem-vec.c:97) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddddddUddUddUdd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048614: apply (sh-mem-vec.c:97) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 7 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x8048625: apply (sh-mem-vec.c:98) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049921 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x8048625: apply (sh-mem-vec.c:98) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +ddddddddUddUddUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048625: apply (sh-mem-vec.c:98) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 8 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x8048636: apply (sh-mem-vec.c:99) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x40499d1 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x8048636: apply (sh-mem-vec.c:99) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddddddddUddUddU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048636: apply (sh-mem-vec.c:99) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 9 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x8048647: apply (sh-mem-vec.c:100) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049a81 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x8048647: apply (sh-mem-vec.c:100) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +ddddddddddUddUdd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048647: apply (sh-mem-vec.c:100) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 10 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x8048658: apply (sh-mem-vec.c:101) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049b31 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x8048658: apply (sh-mem-vec.c:101) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddddddddddUddUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048658: apply (sh-mem-vec.c:101) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 11 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x8048669: apply (sh-mem-vec.c:102) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049be1 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x8048669: apply (sh-mem-vec.c:102) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +ddddddddddddUddU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x8048669: apply (sh-mem-vec.c:102) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 12 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x804867A: apply (sh-mem-vec.c:103) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049c91 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x804867A: apply (sh-mem-vec.c:103) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddddddddddddUdd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x804867A: apply (sh-mem-vec.c:103) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 13 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x804868B: apply (sh-mem-vec.c:104) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049d41 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x804868B: apply (sh-mem-vec.c:104) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +ddddddddddddddUd + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x804868B: apply (sh-mem-vec.c:104) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 14 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x804869C: apply (sh-mem-vec.c:105) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049df1 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x804869C: apply (sh-mem-vec.c:105) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddddddddddddddU + +==31013== Conditional jump or move depends on uninitialised value(s) +==31013== at 0x8048A8F: do_partial_load_case (sh-mem-vec.c:190) +==31013== by 0x804869C: apply (sh-mem-vec.c:105) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +------ PL Unaligned case with 15 leading acc+def bytes ------ + +==31013== Invalid read of size 16 +==31013== at 0x804858C: vector16_copy (sh-mem-vec.c:15) +==31013== by 0x804898B: do_partial_load_case (sh-mem-vec.c:171) +==31013== by 0x80486AD: apply (sh-mem-vec.c:106) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== Address 0x4049ea1 is 1 bytes inside a block of size 64 alloc'd +==31013== at 0x400602A: memalign (vg_replace_malloc.c:755) +==31013== by 0x80487BA: memalign16 (malloc.h:21) +==31013== by 0x8048861: do_partial_load_case (sh-mem-vec.c:149) +==31013== by 0x80486AD: apply (sh-mem-vec.c:106) +==31013== by 0x80490D3: main (sh-mem-vec.c:295) +==31013== + +dddddddddddddddd + + +==31013== +==31013== HEAP SUMMARY: +==31013== in use at exit: 0 bytes in 0 blocks +==31013== total heap usage: 33 allocs, 33 frees, 82,048 bytes allocated +==31013== +==31013== All heap blocks were freed -- no leaks are possible +==31013== +==31013== For counts of detected and suppressed errors, rerun with: -v +==31013== Use --track-origins=yes to see where uninitialised values come from +==31013== ERROR SUMMARY: 51 errors from 51 contexts (suppressed: 0 from 0) diff --git a/out-64-plo-no.txt b/out-64-plo-no.txt new file mode 100644 index 0000000000..d6703ee661 --- /dev/null +++ b/out-64-plo-no.txt @@ -0,0 +1,804 @@ +==31001== Memcheck, a memory error detector +==31001== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al. +==31001== Using Valgrind-3.9.0.SVN and LibVEX; rerun with -h for copyright info +==31001== Command: ./memcheck/tests/sh-mem-vec +==31001== + +20537 136 171 75 38 63 139 23 5 110 66 421 194 86 232 115 + 56 198 303 65 285 137 309 203 147 37 179 137 65 181 379 118 + 91 235 54 135 110 40 362 74 146 108 159 174 313 106 292 271 + 183 65 277 34 250 172 283 111 141 30 26 15 184 93 79 99 + 75 89 153 157 9 113 189 58 90 31 81 79 133 132 61 113 + 282 15 119 12 57 361 14 250 93 116 226 215 229 275 186 126 + 209 371 84 74 93 159 286 179 84 112 60 137 116 117 394 217 + 77 133 197 265 72 43 280 26 604 47 194 171 199 411 123 112 + 281 26 47 64 236 89 223 86 68 125 47 391 18 171 124 110 + 59 135 143 240 73 242 72 59 345 20 46 415 77 87 34 125 + 152 85 107 117 334 183 8 131 63 70 27 238 6 181 71 108 + 242 542 53 94 50 86 181 173 141 125 33 75 409 38 109 70 + 52 179 48 94 212 60 330 150 147 26 462 307 88 171 85 76 + 108 108 296 253 152 124 196 227 116 12 606 61 197 120 94 269 + 121 38 37 167 138 92 172 234 138 67 96 19 346 10 56 241 + 142 130 85 495 65 176 87 140 46 124 70 100 78 142 270 22165 + +160000 copies, 30739 d_aligned, 30741 s_aligned, 7092 both_aligned +0 failures + +Expect 2 x no error + +Expect 2 x error + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x40110C: main (sh-mem-vec.c:276) +==31001== Address 0x483803f is 1 bytes before a block of size 80,000 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400BD7: main (sh-mem-vec.c:205) +==31001== +==31001== Invalid write of size 8 +==31001== at 0x400733: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x401117: main (sh-mem-vec.c:277) +==31001== Address 0x483803f is 1 bytes before a block of size 80,000 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400BD7: main (sh-mem-vec.c:205) +==31001== + +Expect 2 x no error + +Expect 2 x error + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x401183: main (sh-mem-vec.c:285) +==31001== Address 0x484b8b1 is 79,985 bytes inside a block of size 80,000 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400BD7: main (sh-mem-vec.c:205) +==31001== +==31001== Invalid write of size 8 +==31001== at 0x400733: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x40118E: main (sh-mem-vec.c:286) +==31001== Address 0x484b8b9 is 79,993 bytes inside a block of size 80,000 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400BD7: main (sh-mem-vec.c:205) +==31001== + +------ PL Aligned case with 0 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400752: apply (sh-mem-vec.c:91) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484b900 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400752: apply (sh-mem-vec.c:91) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dUddUddUddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x400752: apply (sh-mem-vec.c:91) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 1 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40075D: apply (sh-mem-vec.c:92) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484b980 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40075D: apply (sh-mem-vec.c:92) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +ddUddUddUddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40075D: apply (sh-mem-vec.c:92) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 2 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40076A: apply (sh-mem-vec.c:93) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484ba00 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40076A: apply (sh-mem-vec.c:93) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddUddUddUddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40076A: apply (sh-mem-vec.c:93) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 3 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400775: apply (sh-mem-vec.c:94) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484ba80 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400775: apply (sh-mem-vec.c:94) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +ddddUddUddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x400775: apply (sh-mem-vec.c:94) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 4 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400780: apply (sh-mem-vec.c:95) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bb00 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400780: apply (sh-mem-vec.c:95) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddddUddUddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x400780: apply (sh-mem-vec.c:95) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 5 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40078B: apply (sh-mem-vec.c:96) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bb80 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40078B: apply (sh-mem-vec.c:96) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +ddddddUddUddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40078B: apply (sh-mem-vec.c:96) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 6 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40079A: apply (sh-mem-vec.c:97) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bc00 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40079A: apply (sh-mem-vec.c:97) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddddddUddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40079A: apply (sh-mem-vec.c:97) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 7 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007A5: apply (sh-mem-vec.c:98) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bc80 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007A5: apply (sh-mem-vec.c:98) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +ddddddddUddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007A5: apply (sh-mem-vec.c:98) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 8 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007B0: apply (sh-mem-vec.c:99) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bd00 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007B0: apply (sh-mem-vec.c:99) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddddddddUddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007B0: apply (sh-mem-vec.c:99) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 9 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007BB: apply (sh-mem-vec.c:100) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bd80 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007BB: apply (sh-mem-vec.c:100) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +ddddddddddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007BB: apply (sh-mem-vec.c:100) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 10 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007CA: apply (sh-mem-vec.c:101) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484be00 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007CA: apply (sh-mem-vec.c:101) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddddddddddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007CA: apply (sh-mem-vec.c:101) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 11 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007D5: apply (sh-mem-vec.c:102) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484be80 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007D5: apply (sh-mem-vec.c:102) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +ddddddddddddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007D5: apply (sh-mem-vec.c:102) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 12 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007E0: apply (sh-mem-vec.c:103) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bf00 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007E0: apply (sh-mem-vec.c:103) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddddddddddddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007E0: apply (sh-mem-vec.c:103) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 13 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007EB: apply (sh-mem-vec.c:104) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484bf80 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007EB: apply (sh-mem-vec.c:104) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +ddddddddddddddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007EB: apply (sh-mem-vec.c:104) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 14 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007FA: apply (sh-mem-vec.c:105) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484c000 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007FA: apply (sh-mem-vec.c:105) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddddddddddddddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007FA: apply (sh-mem-vec.c:105) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +------ PL Aligned case with 15 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400805: apply (sh-mem-vec.c:106) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== Address 0x484c080 is 0 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400805: apply (sh-mem-vec.c:106) +==31001== by 0x4011BD: main (sh-mem-vec.c:292) +==31001== + +dddddddddddddddd + + +------ PL Unaligned case with 0 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400752: apply (sh-mem-vec.c:91) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c101 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400752: apply (sh-mem-vec.c:91) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dUddUddUddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x400752: apply (sh-mem-vec.c:91) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 1 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40075D: apply (sh-mem-vec.c:92) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c181 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40075D: apply (sh-mem-vec.c:92) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +ddUddUddUddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40075D: apply (sh-mem-vec.c:92) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 2 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40076A: apply (sh-mem-vec.c:93) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c201 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40076A: apply (sh-mem-vec.c:93) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddUddUddUddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40076A: apply (sh-mem-vec.c:93) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 3 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400775: apply (sh-mem-vec.c:94) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c281 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400775: apply (sh-mem-vec.c:94) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +ddddUddUddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x400775: apply (sh-mem-vec.c:94) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 4 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400780: apply (sh-mem-vec.c:95) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c301 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400780: apply (sh-mem-vec.c:95) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddddUddUddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x400780: apply (sh-mem-vec.c:95) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 5 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40078B: apply (sh-mem-vec.c:96) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c381 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40078B: apply (sh-mem-vec.c:96) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +ddddddUddUddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40078B: apply (sh-mem-vec.c:96) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 6 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x40079A: apply (sh-mem-vec.c:97) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c401 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x40079A: apply (sh-mem-vec.c:97) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddddddUddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x40079A: apply (sh-mem-vec.c:97) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 7 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007A5: apply (sh-mem-vec.c:98) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c481 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007A5: apply (sh-mem-vec.c:98) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +ddddddddUddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007A5: apply (sh-mem-vec.c:98) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 8 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007B0: apply (sh-mem-vec.c:99) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c501 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007B0: apply (sh-mem-vec.c:99) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddddddddUddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007B0: apply (sh-mem-vec.c:99) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 9 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007BB: apply (sh-mem-vec.c:100) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c581 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007BB: apply (sh-mem-vec.c:100) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +ddddddddddUddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007BB: apply (sh-mem-vec.c:100) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 10 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007CA: apply (sh-mem-vec.c:101) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c601 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007CA: apply (sh-mem-vec.c:101) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddddddddddUddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007CA: apply (sh-mem-vec.c:101) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 11 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007D5: apply (sh-mem-vec.c:102) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c681 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007D5: apply (sh-mem-vec.c:102) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +ddddddddddddUddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007D5: apply (sh-mem-vec.c:102) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 12 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007E0: apply (sh-mem-vec.c:103) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c701 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007E0: apply (sh-mem-vec.c:103) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddddddddddddUdd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007E0: apply (sh-mem-vec.c:103) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 13 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007EB: apply (sh-mem-vec.c:104) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c781 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007EB: apply (sh-mem-vec.c:104) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +ddddddddddddddUd + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007EB: apply (sh-mem-vec.c:104) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 14 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x4007FA: apply (sh-mem-vec.c:105) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c801 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x4007FA: apply (sh-mem-vec.c:105) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddddddddddddddU + +==31001== Conditional jump or move depends on uninitialised value(s) +==31001== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31001== by 0x4007FA: apply (sh-mem-vec.c:105) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +------ PL Unaligned case with 15 leading acc+def bytes ------ + +==31001== Invalid read of size 16 +==31001== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31001== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31001== by 0x400805: apply (sh-mem-vec.c:106) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== Address 0x484c881 is 1 bytes inside a block of size 64 alloc'd +==31001== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31001== by 0x40089E: memalign16 (malloc.h:21) +==31001== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31001== by 0x400805: apply (sh-mem-vec.c:106) +==31001== by 0x4011D8: main (sh-mem-vec.c:295) +==31001== + +dddddddddddddddd + + +==31001== +==31001== HEAP SUMMARY: +==31001== in use at exit: 0 bytes in 0 blocks +==31001== total heap usage: 33 allocs, 33 frees, 82,048 bytes allocated +==31001== +==31001== All heap blocks were freed -- no leaks are possible +==31001== +==31001== For counts of detected and suppressed errors, rerun with: -v +==31001== Use --track-origins=yes to see where uninitialised values come from +==31001== ERROR SUMMARY: 66 errors from 66 contexts (suppressed: 0 from 0) diff --git a/out-64-plo-yes.txt b/out-64-plo-yes.txt new file mode 100644 index 0000000000..8bf224e41e --- /dev/null +++ b/out-64-plo-yes.txt @@ -0,0 +1,617 @@ +==31005== Memcheck, a memory error detector +==31005== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al. +==31005== Using Valgrind-3.9.0.SVN and LibVEX; rerun with -h for copyright info +==31005== Command: ./memcheck/tests/sh-mem-vec +==31005== + +20537 136 171 75 38 63 139 23 5 110 66 421 194 86 232 115 + 56 198 303 65 285 137 309 203 147 37 179 137 65 181 379 118 + 91 235 54 135 110 40 362 74 146 108 159 174 313 106 292 271 + 183 65 277 34 250 172 283 111 141 30 26 15 184 93 79 99 + 75 89 153 157 9 113 189 58 90 31 81 79 133 132 61 113 + 282 15 119 12 57 361 14 250 93 116 226 215 229 275 186 126 + 209 371 84 74 93 159 286 179 84 112 60 137 116 117 394 217 + 77 133 197 265 72 43 280 26 604 47 194 171 199 411 123 112 + 281 26 47 64 236 89 223 86 68 125 47 391 18 171 124 110 + 59 135 143 240 73 242 72 59 345 20 46 415 77 87 34 125 + 152 85 107 117 334 183 8 131 63 70 27 238 6 181 71 108 + 242 542 53 94 50 86 181 173 141 125 33 75 409 38 109 70 + 52 179 48 94 212 60 330 150 147 26 462 307 88 171 85 76 + 108 108 296 253 152 124 196 227 116 12 606 61 197 120 94 269 + 121 38 37 167 138 92 172 234 138 67 96 19 346 10 56 241 + 142 130 85 495 65 176 87 140 46 124 70 100 78 142 270 22165 + +160000 copies, 30739 d_aligned, 30741 s_aligned, 7092 both_aligned +0 failures + +Expect 2 x no error + +Expect 2 x error + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x40110C: main (sh-mem-vec.c:276) +==31005== Address 0x483803f is 1 bytes before a block of size 80,000 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400BD7: main (sh-mem-vec.c:205) +==31005== +==31005== Invalid write of size 8 +==31005== at 0x400733: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x401117: main (sh-mem-vec.c:277) +==31005== Address 0x483803f is 1 bytes before a block of size 80,000 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400BD7: main (sh-mem-vec.c:205) +==31005== + +Expect 2 x no error + +Expect 2 x error + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x401183: main (sh-mem-vec.c:285) +==31005== Address 0x484b8b1 is 79,985 bytes inside a block of size 80,000 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400BD7: main (sh-mem-vec.c:205) +==31005== +==31005== Invalid write of size 8 +==31005== at 0x400733: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x40118E: main (sh-mem-vec.c:286) +==31005== Address 0x484b8b9 is 79,993 bytes inside a block of size 80,000 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400BD7: main (sh-mem-vec.c:205) +==31005== + +------ PL Aligned case with 0 leading acc+def bytes ------ + + +UUdUUdUUdUUdUUdU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x400752: apply (sh-mem-vec.c:91) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 1 leading acc+def bytes ------ + + +dUUdUUdUUdUUdUUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40075D: apply (sh-mem-vec.c:92) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 2 leading acc+def bytes ------ + + +ddUUdUUdUUdUUdUU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40076A: apply (sh-mem-vec.c:93) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 3 leading acc+def bytes ------ + + +dddUUdUUdUUdUUdU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x400775: apply (sh-mem-vec.c:94) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 4 leading acc+def bytes ------ + + +ddddUUdUUdUUdUUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x400780: apply (sh-mem-vec.c:95) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 5 leading acc+def bytes ------ + + +dddddUUdUUdUUdUU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40078B: apply (sh-mem-vec.c:96) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 6 leading acc+def bytes ------ + + +ddddddUUdUUdUUdU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40079A: apply (sh-mem-vec.c:97) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 7 leading acc+def bytes ------ + + +dddddddUUdUUdUUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007A5: apply (sh-mem-vec.c:98) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 8 leading acc+def bytes ------ + + +ddddddddUUdUUdUU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007B0: apply (sh-mem-vec.c:99) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 9 leading acc+def bytes ------ + + +dddddddddUUdUUdU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007BB: apply (sh-mem-vec.c:100) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 10 leading acc+def bytes ------ + + +ddddddddddUUdUUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007CA: apply (sh-mem-vec.c:101) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 11 leading acc+def bytes ------ + + +dddddddddddUUdUU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007D5: apply (sh-mem-vec.c:102) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 12 leading acc+def bytes ------ + + +ddddddddddddUUdU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007E0: apply (sh-mem-vec.c:103) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 13 leading acc+def bytes ------ + + +dddddddddddddUUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007EB: apply (sh-mem-vec.c:104) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 14 leading acc+def bytes ------ + + +ddddddddddddddUU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007FA: apply (sh-mem-vec.c:105) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Aligned case with 15 leading acc+def bytes ------ + + +dddddddddddddddU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x400805: apply (sh-mem-vec.c:106) +==31005== by 0x4011BD: main (sh-mem-vec.c:292) +==31005== + +------ PL Unaligned case with 0 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x400752: apply (sh-mem-vec.c:91) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c101 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x400752: apply (sh-mem-vec.c:91) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dUddUddUddUddUdd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x400752: apply (sh-mem-vec.c:91) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 1 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x40075D: apply (sh-mem-vec.c:92) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c181 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x40075D: apply (sh-mem-vec.c:92) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +ddUddUddUddUddUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40075D: apply (sh-mem-vec.c:92) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 2 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x40076A: apply (sh-mem-vec.c:93) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c201 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x40076A: apply (sh-mem-vec.c:93) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddUddUddUddUddU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40076A: apply (sh-mem-vec.c:93) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 3 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x400775: apply (sh-mem-vec.c:94) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c281 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x400775: apply (sh-mem-vec.c:94) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +ddddUddUddUddUdd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x400775: apply (sh-mem-vec.c:94) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 4 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x400780: apply (sh-mem-vec.c:95) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c301 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x400780: apply (sh-mem-vec.c:95) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddddUddUddUddUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x400780: apply (sh-mem-vec.c:95) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 5 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x40078B: apply (sh-mem-vec.c:96) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c381 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x40078B: apply (sh-mem-vec.c:96) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +ddddddUddUddUddU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40078B: apply (sh-mem-vec.c:96) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 6 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x40079A: apply (sh-mem-vec.c:97) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c401 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x40079A: apply (sh-mem-vec.c:97) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddddddUddUddUdd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x40079A: apply (sh-mem-vec.c:97) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 7 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007A5: apply (sh-mem-vec.c:98) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c481 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007A5: apply (sh-mem-vec.c:98) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +ddddddddUddUddUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007A5: apply (sh-mem-vec.c:98) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 8 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007B0: apply (sh-mem-vec.c:99) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c501 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007B0: apply (sh-mem-vec.c:99) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddddddddUddUddU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007B0: apply (sh-mem-vec.c:99) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 9 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007BB: apply (sh-mem-vec.c:100) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c581 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007BB: apply (sh-mem-vec.c:100) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +ddddddddddUddUdd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007BB: apply (sh-mem-vec.c:100) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 10 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007CA: apply (sh-mem-vec.c:101) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c601 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007CA: apply (sh-mem-vec.c:101) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddddddddddUddUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007CA: apply (sh-mem-vec.c:101) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 11 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007D5: apply (sh-mem-vec.c:102) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c681 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007D5: apply (sh-mem-vec.c:102) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +ddddddddddddUddU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007D5: apply (sh-mem-vec.c:102) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 12 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007E0: apply (sh-mem-vec.c:103) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c701 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007E0: apply (sh-mem-vec.c:103) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddddddddddddUdd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007E0: apply (sh-mem-vec.c:103) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 13 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007EB: apply (sh-mem-vec.c:104) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c781 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007EB: apply (sh-mem-vec.c:104) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +ddddddddddddddUd + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007EB: apply (sh-mem-vec.c:104) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 14 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x4007FA: apply (sh-mem-vec.c:105) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c801 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x4007FA: apply (sh-mem-vec.c:105) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddddddddddddddU + +==31005== Conditional jump or move depends on uninitialised value(s) +==31005== at 0x400B86: do_partial_load_case (sh-mem-vec.c:190) +==31005== by 0x4007FA: apply (sh-mem-vec.c:105) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +------ PL Unaligned case with 15 leading acc+def bytes ------ + +==31005== Invalid read of size 16 +==31005== at 0x400730: vector16_copy (sh-mem-vec.c:15) +==31005== by 0x400A86: do_partial_load_case (sh-mem-vec.c:171) +==31005== by 0x400805: apply (sh-mem-vec.c:106) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== Address 0x484c881 is 1 bytes inside a block of size 64 alloc'd +==31005== at 0x480690E: memalign (vg_replace_malloc.c:755) +==31005== by 0x40089E: memalign16 (malloc.h:21) +==31005== by 0x400927: do_partial_load_case (sh-mem-vec.c:149) +==31005== by 0x400805: apply (sh-mem-vec.c:106) +==31005== by 0x4011D8: main (sh-mem-vec.c:295) +==31005== + +dddddddddddddddd + + +==31005== +==31005== HEAP SUMMARY: +==31005== in use at exit: 0 bytes in 0 blocks +==31005== total heap usage: 33 allocs, 33 frees, 82,048 bytes allocated +==31005== +==31005== All heap blocks were freed -- no leaks are possible +==31005== +==31005== For counts of detected and suppressed errors, rerun with: -v +==31005== Use --track-origins=yes to see where uninitialised values come from +==31005== ERROR SUMMARY: 51 errors from 51 contexts (suppressed: 0 from 0)