1
2 /*
3 gcc -g -o v8memory_a -march=armv8-a -mfpu=crypto-neon-fp-armv8 \
4 none/tests/arm/v8memory.c -I. -Wall -marm
5
6 gcc -g -o v8memory_t -march=armv8-a -mfpu=crypto-neon-fp-armv8 \
7 none/tests/arm/v8memory.c -I. -Wall -mthumb
8 */
9
10 /* These tests unfortunately are unable to check the relative
11 placement (or, even, presence) of the required memory fences
12 relative to the store/load required. They only verify the
13 data-movement component. */
14
15 #include <stdio.h>
16 #include <malloc.h> // memalign
17 #include <string.h> // memset
18 #include "tests/malloc.h"
19 #include <assert.h>
20
21 typedef unsigned char UChar;
22 typedef unsigned short int UShort;
23 typedef unsigned int UInt;
24 typedef signed int Int;
25 typedef unsigned char UChar;
26 typedef signed long long int Long;
27 typedef unsigned long long int ULong;
28
29 typedef unsigned char Bool;
30 #define False ((Bool)0)
31 #define True ((Bool)1)
32
randUChar(void)33 static inline UChar randUChar ( void )
34 {
35 static UInt seed = 90210; // Somewhere in Beverly Hills, allegedly.
36 seed = 1103515245 * seed + 12345;
37 return (seed >> 17) & 0xFF;
38 }
39
randUInt(void)40 static UInt randUInt ( void )
41 {
42 Int i;
43 UInt r = 0;
44 for (i = 0; i < 4; i++) {
45 r = (r << 8) | (UInt)(0xFF & randUChar());
46 }
47 return r;
48 }
49
show_block_xor(UChar * block1,UChar * block2,Int n)50 static void show_block_xor ( UChar* block1, UChar* block2, Int n )
51 {
52 Int i;
53 printf(" ");
54 for (i = 0; i < n; i++) {
55 if (i > 0 && 0 == (i & 15)) printf("\n ");
56 if (0 == (i & 15)) printf("[%3d] ", i);
57 UInt diff = 0xFF & (UInt)(block1[i] - block2[i]);
58 if (diff == 0)
59 printf(".. ");
60 else
61 printf("%02x ", diff);
62 }
63 printf("\n");
64 }
65
66
67 // INSN may mention the following regs as containing load/store data:
68 // r2 r3 r6 r9
69 // INSN must mention the following reg as containing the EA: r10
70 //
71 // INSN can use r4 and r5 as scratch
72 //
73 // In: rand: memory area (128 bytes), r2, r3, r6, r9
74 // r10 pointing to middle of memory area
75 //
76 // Out: memory area, r2, r3, r6, r9, r10
77 //
78 // What is printed out: the XOR of the new and old versions of the
79 // following:
80 // the memory area
81 // r2, r3 r6 r9 r10
82
83 #define MEM_TEST(INSN) { \
84 int i; \
85 const int N = 128; \
86 UChar* area1 = memalign16(N); \
87 UChar* area2 = memalign16(N); \
88 for (i = 0; i < N; i++) area1[i] = area2[i] = randUChar(); \
89 UInt block1[5]; \
90 UInt block2[5]; \
91 /* 0:r2 1:r3 2:r6 3:r9 4:r10 */ \
92 for (i = 0; i < 5; i++) block1[i] = block2[i] = randUInt(); \
93 block1[4] = block2[4] = (UInt)(&area1[N/2]); \
94 __asm__ __volatile__( \
95 "ldr r2, [%0, #0] ; " \
96 "ldr r3, [%0, #4] ; " \
97 "ldr r6, [%0, #8] ; " \
98 "ldr r9, [%0, #12] ; " \
99 "ldr r10, [%0, #16] ; " \
100 INSN " ; " \
101 "str r2, [%0, #0] ; " \
102 "str r3, [%0, #4] ; " \
103 "str r6, [%0, #8] ; " \
104 "str r9, [%0, #12] ; " \
105 "str r10, [%0, #16] ; " \
106 : : "r"(&block1[0]) : "r2", "r3", "r4", "r5", "r6", "r9", "r10", \
107 "memory", "cc" \
108 ); \
109 printf("%s with r10 = middle_of_block\n", INSN); \
110 show_block_xor(&area1[0], &area2[0], N); \
111 printf(" %08x r2 (xor, data intreg #1)\n", block1[0] ^ block2[0]); \
112 printf(" %08x r3 (xor, data intreg #2)\n", block1[1] ^ block2[1]); \
113 printf(" %08x r6 (xor, data intreg #3)\n", block1[2] ^ block2[2]); \
114 printf(" %08x r9 (xor, data intreg #4)\n", block1[3] ^ block2[3]); \
115 printf(" %08x r10 (xor, addr intreg #1)\n", block1[4] ^ block2[4]); \
116 printf("\n"); \
117 free(area1); free(area2); \
118 }
119
120
main(void)121 int main ( void )
122 {
123 ////////////////////////////////////////////////////////////////
124 printf("LDA{,B,H} (reg)\n\n");
125 MEM_TEST("lda r6, [r10]")
126 MEM_TEST("ldab r9, [r10]")
127 MEM_TEST("ldah r3, [r10]")
128
129 ////////////////////////////////////////////////////////////////
130 printf("STL{,B,H} (reg)\n\n");
131 MEM_TEST("stl r6, [r10]")
132 MEM_TEST("stlb r9, [r10]")
133 MEM_TEST("stlh r3, [r10]")
134
135 ////////////////////////////////////////////////////////////////
136 printf("LDAEX{,B,H,D} (reg)\n\n");
137 MEM_TEST("ldaex r6, [r10]")
138 MEM_TEST("ldaexb r9, [r10]")
139 MEM_TEST("ldaexh r3, [r10]")
140 MEM_TEST("ldaexd r2, r3, [r10]")
141
142 ////////////////////////////////////////////////////////////////
143 // These verify that stlex* do notice a cleared (missing) reservation.
144 printf("STLEX{,B,H,D} (reg) -- expected to fail\n\n");
145 MEM_TEST("clrex; stlex r9, r6, [r10]")
146 MEM_TEST("clrex; stlexb r9, r6, [r10]")
147 MEM_TEST("clrex; stlexh r9, r3, [r10]")
148 MEM_TEST("clrex; stlexd r9, r2, r3, [r10]")
149
150 ////////////////////////////////////////////////////////////////
151 // These verify that stlex* do notice a successful reservation.
152 // By using ldaex* to create the reservation in the first place,
153 // they also verify that ldaex* actually create a reservation.
154 printf("STLEX{,B,H,D} (reg) -- expected to succeed\n\n");
155 MEM_TEST("ldaex r2, [r10] ; stlex r9, r6, [r10]")
156 MEM_TEST("ldaexb r2, [r10] ; stlexb r9, r6, [r10]")
157 MEM_TEST("ldaexh r2, [r10] ; stlexh r9, r3, [r10]")
158 MEM_TEST("mov r4, r2 ; mov r5, r3 ; " // preserve r2/r3 around the ldrexd
159 "ldaexd r2, r3, [r10] ; "
160 "mov r2, r4 ; mov r3, r5 ; "
161 "stlexd r9, r2, r3, [r10]")
162
163 return 0;
164 }
165