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 \
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
insn-pcmpistri \
insn-pmovmskb \
more_x87_fp \
+ sh-mem-vec128 \
sse_memory \
xor-undef-amd64
--- /dev/null
+prog: sh-mem-vec128
+args: -q
+vgopts: --partial-loads-ok=no
--- /dev/null
+prog: sh-mem-vec128
+args: -q
+vgopts: --partial-loads-ok=yes
--- /dev/null
+
+// 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"
--- /dev/null
+
+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
--- /dev/null
+
+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)
--- /dev/null
+
+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)
--- /dev/null
+
+// Tests shadow memory correctness for 16-byte vector loads/stores
+// Requires vector16_copy() to be specified somehow.
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#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;
+}
+
+++ /dev/null
-
-// Tests shadow memory correctness for 16-byte vector loads/stores
-
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#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 <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#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;
-}
+++ /dev/null
-==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)
+++ /dev/null
-==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)
projects / thirdparty / valgrind.git / commitdiff
