Wrap calls to memcpy(3) in a function called block_copy(). This way,

and as long as we're not compiling with IPA, gcc(1) won't optimize
the call away. The whole purpose of using memcpy(3) is to avoid
misaligned loads and stores when we need to read or write the value
in the unaligned memory location. But if gcc(1) optimizes the call
to memcpy(3) away, it will typically introduce misaligned loads and
stores. In this context that's not a good idea.

1 files changed, 9 insertions, 2 deletions

diff --git a/tools/regression/ia64/unaligned/test.c b/tools/regression/ia64/unaligned/test.c
index e6c8bb4..869c864 100644
--- a/tools/regression/ia64/unaligned/test.c
+++ b/tools/regression/ia64/unaligned/test.c
@@ -101,6 +101,13 @@ DATA_TYPE *aligned = &data.aligned;
 DATA_TYPE *misaligned = (DATA_TYPE *)data.misaligned;
 DATA_TYPE value = DATA_VALUE;
 
+void
+block_copy(void *dst, void *src, size_t sz)
+{
+
+	memcpy(dst, src, sz);
+}
+
 int
 main()
 {
@@ -112,7 +119,7 @@ main()
 	/*
 	 * LOAD
 	 */
-	memcpy(misaligned, &value, sizeof(DATA_TYPE));
+	block_copy(misaligned, &value, sizeof(DATA_TYPE));
 
 #  if POSTINC == NoPostInc
 	/* Misaligned load. */
@@ -179,7 +186,7 @@ main()
 	return (1);
 #  endif
 
-	memcpy(aligned, data.misaligned, sizeof(DATA_TYPE));
+	block_copy(aligned, data.misaligned, sizeof(DATA_TYPE));
 #endif
 
 	if (*aligned != value)