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 */
10typedef 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 */
22uint32_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 */
29uint32_t pattern4[] = {
30   0x00010000, 0x0010ffff,    /* corner cases */
31   0x00010123, 0x00023456, 0x000789ab, 0x00100000  /* misc */
32};
33
34/* Invalid UTF-32 character */
35uint32_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 */
43uint32_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. */
52uint16_t buff[1000];  /* Large so we con'don't have to worry about it */
53
54void write_and_check(uint32_t *, unsigned, unsigned);
55
56
57static cu42_t
58do_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
88void
89run_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
117int 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
205void
206write_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
227void
228write_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