diff --git a/memcheck/tests/Makefile.am b/memcheck/tests/Makefile.am index 9511dc86d..e363df48e 100644 --- a/memcheck/tests/Makefile.am +++ b/memcheck/tests/Makefile.am @@ -36,7 +36,8 @@ if VGCONF_PLATFORMS_INCLUDE_AMD64_LINUX SUBDIRS += amd64-linux endif -DIST_SUBDIRS = x86 amd64 ppc32 ppc64 s390x linux darwin x86-linux amd64-linux . +DIST_SUBDIRS = x86 amd64 ppc32 ppc64 s390x linux \ + darwin x86-linux amd64-linux common . dist_noinst_SCRIPTS = \ filter_addressable \ diff --git a/memcheck/tests/amd64/Makefile.am b/memcheck/tests/amd64/Makefile.am index bac7551da..648a13f08 100644 --- a/memcheck/tests/amd64/Makefile.am +++ b/memcheck/tests/amd64/Makefile.am @@ -18,6 +18,12 @@ EXTRA_DIST = \ insn-pcmpistri.vgtest insn-pcmpistri.stdout.exp insn-pcmpistri.stderr.exp \ insn-pmovmskb.vgtest insn-pmovmskb.stdout.exp insn-pmovmskb.stderr.exp \ more_x87_fp.stderr.exp more_x87_fp.stdout.exp more_x87_fp.vgtest \ + sh-mem-vec128-plo-no.vgtest \ + sh-mem-vec128-plo-no.stderr.exp \ + sh-mem-vec128-plo-no.stdout.exp \ + sh-mem-vec128-plo-yes.vgtest \ + sh-mem-vec128-plo-yes.stderr.exp \ + sh-mem-vec128-plo-yes.stdout.exp \ sse_memory.stderr.exp sse_memory.stdout.exp sse_memory.vgtest \ xor-undef-amd64.stderr.exp xor-undef-amd64.stdout.exp \ xor-undef-amd64.vgtest @@ -31,6 +37,7 @@ check_PROGRAMS = \ insn-pcmpistri \ insn-pmovmskb \ more_x87_fp \ + sh-mem-vec128 \ sse_memory \ xor-undef-amd64 diff --git a/memcheck/tests/amd64/sh-mem-vec128-plo-no.vgtest b/memcheck/tests/amd64/sh-mem-vec128-plo-no.vgtest new file mode 100644 index 000000000..160b95b28 --- /dev/null +++ b/memcheck/tests/amd64/sh-mem-vec128-plo-no.vgtest @@ -0,0 +1,3 @@ +prog: sh-mem-vec128 +args: -q +vgopts: --partial-loads-ok=no diff --git a/memcheck/tests/amd64/sh-mem-vec128-plo-yes.vgtest b/memcheck/tests/amd64/sh-mem-vec128-plo-yes.vgtest new file mode 100644 index 000000000..76585dd37 --- /dev/null +++ b/memcheck/tests/amd64/sh-mem-vec128-plo-yes.vgtest @@ -0,0 +1,3 @@ +prog: sh-mem-vec128 +args: -q +vgopts: --partial-loads-ok=yes diff --git a/memcheck/tests/amd64/sh-mem-vec128.c b/memcheck/tests/amd64/sh-mem-vec128.c new file mode 100644 index 000000000..a5d0a1db8 --- /dev/null +++ b/memcheck/tests/amd64/sh-mem-vec128.c @@ -0,0 +1,16 @@ + +// Set up the 128-bit shadow memory test, by defining the +// required vector-copy function, and then including the +// template. + +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" + ); +} + +// Include the test body, which refers to the above function +#include "../common/sh-mem-vec128.tmpl.c" diff --git a/memcheck/tests/common/Makefile.am b/memcheck/tests/common/Makefile.am new file mode 100644 index 000000000..97aded5d8 --- /dev/null +++ b/memcheck/tests/common/Makefile.am @@ -0,0 +1,9 @@ + +include $(top_srcdir)/Makefile.tool-tests.am + +EXTRA_DIST = \ + sh-mem-vec128.tmpl.c \ + sh-mem-vec128-plo-no.stderr.exp-32bit \ + sh-mem-vec128-plo-yes.stderr.exp-32bit \ + sh-mem-vec128-plo-no.stderr.exp-64bit \ + sh-mem-vec128-plo-yes.stderr.exp-64bit diff --git a/out-32-plo-no.txt b/memcheck/tests/common/sh-mem-vec128-plo-no.stderr.exp-32bit similarity index 100% rename from out-32-plo-no.txt rename to memcheck/tests/common/sh-mem-vec128-plo-no.stderr.exp-32bit diff --git a/memcheck/tests/common/sh-mem-vec128-plo-no.stderr.exp-64bit b/memcheck/tests/common/sh-mem-vec128-plo-no.stderr.exp-64bit new file mode 100644 index 000000000..8cefd389c --- /dev/null +++ b/memcheck/tests/common/sh-mem-vec128-plo-no.stderr.exp-64bit @@ -0,0 +1,541 @@ + +sh-mem-vec128: config: little-endian, 64-bit word size + +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 + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes before a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + +Invalid write of size 8 + ... + Address 0x........ is 1 bytes before a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +Expect 2 x no error + +Expect 2 x error + +Invalid read of size 16 + ... + Address 0x........ is 79,985 bytes inside a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + +Invalid write of size 8 + ... + Address 0x........ is 79,993 bytes inside a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +------ PL Aligned case with 0 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dUddUddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 1 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddUddUddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 2 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddUddUddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 3 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddUddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 4 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddUddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 5 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddUddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 6 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 7 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 8 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 9 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 10 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 11 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 12 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 13 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddddddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 14 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 15 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 0 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddddd + + +------ PL Unaligned case with 0 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dUddUddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 1 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddUddUddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 2 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddUddUddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 3 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddUddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 4 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddUddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 5 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddUddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 6 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 7 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 8 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 9 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 10 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 11 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 12 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 13 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddddddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 14 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 15 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddddd + + + +HEAP SUMMARY: + in use at exit: 0 bytes in 0 blocks + total heap usage: 33 allocs, 33 frees, 82,048 bytes allocated + +For a detailed leak analysis, rerun with: --leak-check=full + +For counts of detected and suppressed errors, rerun with: -v +Use --track-origins=yes to see where uninitialised values come from +ERROR SUMMARY: 66 errors from 66 contexts (suppressed: 0 from 0) diff --git a/out-32-plo-yes.txt b/memcheck/tests/common/sh-mem-vec128-plo-yes.stderr.exp-32bit similarity index 100% rename from out-32-plo-yes.txt rename to memcheck/tests/common/sh-mem-vec128-plo-yes.stderr.exp-32bit diff --git a/memcheck/tests/common/sh-mem-vec128-plo-yes.stderr.exp-64bit b/memcheck/tests/common/sh-mem-vec128-plo-yes.stderr.exp-64bit new file mode 100644 index 000000000..ea2fceebf --- /dev/null +++ b/memcheck/tests/common/sh-mem-vec128-plo-yes.stderr.exp-64bit @@ -0,0 +1,448 @@ + +sh-mem-vec128: config: little-endian, 64-bit word size + +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 + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes before a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + +Invalid write of size 8 + ... + Address 0x........ is 1 bytes before a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +Expect 2 x no error + +Expect 2 x error + +Invalid read of size 16 + ... + Address 0x........ is 79,985 bytes inside a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + +Invalid write of size 8 + ... + Address 0x........ is 79,993 bytes inside a block of size 80,000 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +------ PL Aligned case with 0 leading acc+def bytes ------ + + +UUdUUdUUdUUdUUdU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 1 leading acc+def bytes ------ + + +dUUdUUdUUdUUdUUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 2 leading acc+def bytes ------ + + +ddUUdUUdUUdUUdUU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 3 leading acc+def bytes ------ + + +dddUUdUUdUUdUUdU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 4 leading acc+def bytes ------ + + +ddddUUdUUdUUdUUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 5 leading acc+def bytes ------ + + +dddddUUdUUdUUdUU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 6 leading acc+def bytes ------ + + +ddddddUUdUUdUUdU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 7 leading acc+def bytes ------ + + +dddddddUUdUUdUUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 8 leading acc+def bytes ------ + + +ddddddddUUdUUdUU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 9 leading acc+def bytes ------ + + +dddddddddUUdUUdU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 10 leading acc+def bytes ------ + + +ddddddddddUUdUUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 11 leading acc+def bytes ------ + + +dddddddddddUUdUU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 12 leading acc+def bytes ------ + + +ddddddddddddUUdU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 13 leading acc+def bytes ------ + + +dddddddddddddUUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 14 leading acc+def bytes ------ + + +ddddddddddddddUU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Aligned case with 15 leading acc+def bytes ------ + + +dddddddddddddddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 0 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dUddUddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 1 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddUddUddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 2 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddUddUddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 3 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddUddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 4 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddUddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 5 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddUddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 6 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddUddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 7 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddUddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 8 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddUddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 9 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddUddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 10 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddUddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 11 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddddUddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 12 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddUdd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 13 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +ddddddddddddddUd + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 14 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddddU + +Conditional jump or move depends on uninitialised value(s) + ... + + +------ PL Unaligned case with 15 leading acc+def bytes ------ + +Invalid read of size 16 + ... + Address 0x........ is 1 bytes inside a block of size 64 alloc'd + at 0x........: memalign (vg_replace_malloc.c:...) + ... + + +dddddddddddddddd + + + +HEAP SUMMARY: + in use at exit: 0 bytes in 0 blocks + total heap usage: 33 allocs, 33 frees, 82,048 bytes allocated + +For a detailed leak analysis, rerun with: --leak-check=full + +For counts of detected and suppressed errors, rerun with: -v +Use --track-origins=yes to see where uninitialised values come from +ERROR SUMMARY: 51 errors from 51 contexts (suppressed: 0 from 0) diff --git a/memcheck/tests/common/sh-mem-vec128.tmpl.c b/memcheck/tests/common/sh-mem-vec128.tmpl.c new file mode 100644 index 000000000..e49eeaeaf --- /dev/null +++ b/memcheck/tests/common/sh-mem-vec128.tmpl.c @@ -0,0 +1,310 @@ + +// Tests shadow memory correctness for 16-byte vector loads/stores +// Requires vector16_copy() to be specified somehow. + +#include +#include +#include +#include +#include "tests/malloc.h" +#include "memcheck/memcheck.h" + +// What we're actually testing +// .. is vector16_copy, which should be defined before this point + +// 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 __attribute__((noinline)) const char* get_endianness ( void ) +{ + volatile U4 w32 = 0x88776655; + volatile U1* p = (U1*)&w32; + if (p[0] == 0x55) { + assert(p[3] == 0x88); + return "little"; + } + if (p[0] == 0x88) { + assert(p[3] == 0x55); + return "big"; + } + assert(0); +} + +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 ) +{ + fprintf(stderr, "sh-mem-vec128: config: %s-endian, %lu-bit word size\n", + get_endianness(), 8 * sizeof(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; +} + diff --git a/memcheck/tests/sh-mem-vec.c b/memcheck/tests/sh-mem-vec.c deleted file mode 100644 index cb2e0440a..000000000 --- a/memcheck/tests/sh-mem-vec.c +++ /dev/null @@ -1,551 +0,0 @@ - -// 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-64-plo-no.txt b/out-64-plo-no.txt deleted file mode 100644 index d6703ee66..000000000 --- a/out-64-plo-no.txt +++ /dev/null @@ -1,804 +0,0 @@ -==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 deleted file mode 100644 index 8bf224e41..000000000 --- a/out-64-plo-yes.txt +++ /dev/null @@ -1,617 +0,0 @@ -==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)