1 #include <stdint.h>
2 #include <inttypes.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <stdio.h>
6 #include <assert.h>
7 #include "opcodes.h"
8
9 /* The abstracted result of an CU42 insn */
10 typedef struct {
11 uint64_t addr1; // target
12 uint64_t len1;
13 uint64_t addr2; // source
14 uint64_t len2;
15 uint32_t cc;
16 } cu42_t;
17
18 /* Define various input buffers. */
19
20 /* U+0000 to U+d7ff: Result is 2 bytes for each uint32_t
21 U+dc00 to U+ffff: Result is 2 bytes for each uint32_t */
22 uint32_t pattern2[] = {
23 0x0000, 0xd7ff, /* corner cases */
24 0xdc00, 0xffff, /* corner cases */
25 0xabba, 0xf00d, 0xd00f, 0x1234 /* misc */
26 };
27
28 /* U+00010000 to U+0010ffff: Result is 4 bytes for each uint32_t */
29 uint32_t pattern4[] = {
30 0x00010000, 0x0010ffff, /* corner cases */
31 0x00010123, 0x00023456, 0x000789ab, 0x00100000 /* misc */
32 };
33
34 /* Invalid UTF-32 character */
35 uint32_t invalid[] = {
36 0x0000d800, 0x0000dbff, /* corner cases */
37 0x00110000, 0xffffffff, /* corner cases */
38 0x0000daad, 0x0000d901, 0x0000d8ff, /* misc */
39 0x00110011, 0x01000000, 0x10000000, 0xdeadbeef /* misc */
40 };
41
42 /* Mixed bytes */
43 uint32_t mixed[] = {
44 0x00000078 /* 2 bytes */,
45 0x0000d000 /* 2 bytes */,
46 0x00033333 /* 4 bytes */,
47 0x00040404 /* 4 bytes */,
48 0x0000abcd /* 2 bytes */,
49 };
50
51 /* This is the buffer for the converted bytes. */
52 uint16_t buff[1000]; /* Large so we con'don't have to worry about it */
53
54 void write_and_check(uint32_t *, unsigned, unsigned);
55
56
57 static cu42_t
do_cu42(uint16_t * dst,uint64_t dst_len,uint32_t * src,uint64_t src_len)58 do_cu42(uint16_t *dst, uint64_t dst_len, uint32_t *src, uint64_t src_len)
59 {
60 int cc = 42;
61 cu42_t regs;
62
63 /* build up the register pairs */
64 register uint32_t *source asm("4") = src;
65 register uint64_t source_len asm("5") = src_len;
66 register uint16_t *dest asm("2") = dst;
67 register uint64_t dest_len asm("3") = dst_len;
68
69 asm volatile(
70 CU42(2,4)
71 "ipm %2\n\t"
72 "srl %2,28\n\t"
73 : "+d"(dest), "+d"(source), "=d"(cc),
74 "+d"(source_len), "+d"(dest_len)
75 :
76 : "memory", "cc");
77
78 /* Capture register contents at end of cu42 */
79 regs.addr1 = (uint64_t)dest;
80 regs.len1 = dest_len;
81 regs.addr2 = (uint64_t)source;
82 regs.len2 = source_len;
83 regs.cc = cc;
84
85 return regs;
86 }
87
88 void
run_test(uint16_t * dst,uint64_t dst_len,uint32_t * src,uint64_t src_len)89 run_test(uint16_t *dst, uint64_t dst_len, uint32_t *src, uint64_t src_len)
90 {
91 int i;
92 cu42_t result;
93
94 result = do_cu42(dst, dst_len, src, src_len);
95
96 // Write out the converted values, if any
97 printf("UTF16: ");
98 if (dst_len - result.len1 == 0)
99 printf(" <none>");
100 else
101 assert((dst_len - result.len1) % 2 == 0);
102 for (i = 0; i < (dst_len - result.len1) / 2; ++i) {
103 printf(" %04x", dst[i]);
104 }
105 printf("\n");
106
107 printf(" cc = %d\n", result.cc);
108 if (dst != NULL)
109 printf(" dst address difference: %"PRId64, result.addr1 - (uint64_t)dst);
110 printf(" dst len: %"PRId64"\n", result.len1);
111
112 if (src != NULL)
113 printf(" src address difference: %"PRId64, result.addr2 - (uint64_t)src);
114 printf(" src len: %"PRId64"\n", result.len2);
115 }
116
main()117 int main()
118 {
119 int i;
120
121 /* Length == 0, no memory should be read or written */
122 printf("\n------------- test1 ----------------\n");
123 run_test(NULL, 0, NULL, 0);
124
125 /* Test exhaustion of source length (source bytes are valid) */
126 printf("\n------------- test2.1 ----------------\n");
127
128 /* No character will be written to BUFF, i.e. loop in jitted code
129 is not iterated */
130 run_test(buff, sizeof buff, NULL, 0);
131 run_test(buff, sizeof buff, NULL, 1);
132 run_test(buff, sizeof buff, NULL, 2);
133 run_test(buff, sizeof buff, NULL, 3);
134 run_test(buff, sizeof buff, pattern2, 0);
135 run_test(buff, sizeof buff, pattern2, 1);
136 run_test(buff, sizeof buff, pattern2, 2);
137 run_test(buff, sizeof buff, pattern2, 3);
138
139 printf("\n------------- test2.2 ----------------\n");
140 /* At least one character will be written to BUFF, i.e. loop in jitted
141 code is iterated */
142 run_test(buff, sizeof buff, pattern2, 4); /* 1 utf32 -> 1 utf16 */
143 run_test(buff, sizeof buff, pattern2, 10); /* 2 utf32 -> 2 utf16 */
144 run_test(buff, sizeof buff, pattern4, 5); /* 1 utf32 -> 2 utf16 */
145 run_test(buff, sizeof buff, pattern4, 11); /* 2 utf32 -> 4 utf16 */
146 run_test(buff, sizeof buff, pattern4, 18); /* 4 utf32 -> 8 utf16 */
147
148 /* Test exhaustion of destination length (source bytes are valid) */
149 printf("\n------------- test3.1 ----------------\n");
150
151 /* No character will be written to BUFF, i.e. loop in jitted code
152 is not iterated */
153
154 /* Want to write at least 1 UTF-16 */
155 run_test(NULL, 0, pattern2, sizeof pattern2);
156
157 /* Want to write at least 1 UTF-16 */
158 run_test(NULL, 0, pattern2, sizeof pattern2);
159 run_test(NULL, 1, pattern2, sizeof pattern2);
160
161 /* Want to write at least 2 UTF-16 */
162 run_test(NULL, 0, pattern4, sizeof pattern4);
163 run_test(NULL, 1, pattern4, sizeof pattern4);
164 run_test(NULL, 2, pattern4, sizeof pattern4);
165 run_test(NULL, 3, pattern4, sizeof pattern4);
166
167 /* When both operands are exhausted, cc=0 takes precedence.
168 (test1 tests this for len == 0) */
169 printf("\n------------- test4 ----------------\n");
170 run_test(buff, 4, pattern2, 8);
171
172 /* Input contains invalid characters */
173
174 // As conversion stops upon encountering an invalid character, we
175 // need to test each invalid character separately, to make sure it
176 // is recognized as invalid.
177
178 printf("\n------------- test5 ----------------\n");
179 for (i = 0; i < sizeof invalid / 4; ++i) {
180 run_test(buff, sizeof buff, invalid + i, 4);
181 }
182 run_test(buff, 0, invalid, sizeof invalid); // cc = 2
183 run_test(buff, 100, invalid, sizeof invalid);
184
185 /* Convert all pattern buffers */
186 printf("\n------------- test6 ----------------\n");
187 run_test(buff, sizeof buff, pattern2, sizeof pattern2);
188 run_test(buff, sizeof buff, pattern4, sizeof pattern4);
189 run_test(buff, sizeof buff, mixed, sizeof mixed);
190
191 /* Make sure we only write the exact number of bytes (and not more) */
192
193 /* Write 2 bytes */
194 printf("\n------------- test7.1 ----------------\n");
195 write_and_check(pattern2 + 3, 4, 2);
196
197 /* Write 4 bytes */
198 printf("\n------------- test7.2 ----------------\n");
199 write_and_check(pattern4 + 5, 4, 4);
200
201 return 0;
202 }
203
204
205 void
write_and_check_aux(uint32_t * input,unsigned num_input_bytes,unsigned num_expected_output_bytes,unsigned fill_byte)206 write_and_check_aux(uint32_t *input, unsigned num_input_bytes,
207 unsigned num_expected_output_bytes,
208 unsigned fill_byte)
209 {
210 int num_errors, i;
211
212 /* Fill output buffer with FILL_BYTE */
213 memset(buff, fill_byte, sizeof buff);
214
215 /* Execute cu42 */
216 run_test(buff, sizeof buff, input, num_input_bytes);
217
218 /* Make sure the rest of the buffer is unmodified. */
219 num_errors = 0;
220 for (i = num_expected_output_bytes; i < sizeof buff; ++i)
221 if (((unsigned char *)buff)[i] != fill_byte) ++num_errors;
222 if (num_errors)
223 fprintf(stderr, "*** wrote more than %d bytes\n",
224 num_expected_output_bytes);
225 }
226
227 void
write_and_check(uint32_t * input,unsigned num_input_bytes,unsigned num_expected_output_bytes)228 write_and_check(uint32_t *input, unsigned num_input_bytes,
229 unsigned num_expected_output_bytes)
230 {
231 write_and_check_aux(input, num_input_bytes, num_expected_output_bytes, 0x0);
232
233 /* Run again with different fill pattern to make sure we did not write
234 an extra 0x0 byte */
235 write_and_check_aux(input, num_input_bytes, num_expected_output_bytes, 0xFF);
236 }
237