cu41.c revision 663860b1408516d02ebfcb3a9999a134e6cfb223 
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 CU41 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} cu41_t;
17
18/* Define various input buffers. */
19
20/* 0000 to 00ff:  Result is 1 byte for each uint32_t */
21uint32_t pattern1[] = {
22   0x0000, 0x007f,    /* corner cases */
23   0x0001, 0x007e, 0x0030, 0x005e /* misc */
24};
25
26/* 0080 to 07ff: Result is 2 bytes for each uint32_t */
27uint32_t pattern2[] = {
28   0x0080, 0x07ff,    /* corner cases */
29   0x0081, 0x07fe, 0x100, 0x333, 0x555, 0x6aa  /* misc */
30};
31
32/* 0800 to d7ff: Result is 3 bytes for each uint32_t */
33/* dc00 to ffff: Result is 3 bytes for each uint32_t */
34uint32_t pattern3[] = {
35   0x0800, 0xd7ff,    /* corner cases */
36   0xdc00, 0xffff,    /* corner cases */
37   0xdc01, 0xfffe, 0xdea0, 0xd00d, 0xe555  /* misc */
38};
39
40/* 10000 to 10ffff: Result is 4 bytes for each uint32_t */
41uint32_t pattern4[] = {
42   0x10000, 0x10ffff,    /* corner cases */
43   0x10001, 0x10fffe, 0x12345, 0x23456, 0xfedcb  /* misc */
44};
45
46/* Invalid UTF-32 character */
47uint32_t invalid[] = {
48   0x0000d800, 0x0000dbff,   /* corner cases */
49   0x00110000, 0xffffffff,   /* corner cases */
50   0x0000daad, 0x0000d901, 0x0000d8ff, /* misc */
51   0x00110011, 0x01000000, 0x10000000, 0xdeadbeef  /* misc */
52};
53
54/* Mixed bytes */
55uint32_t mixed[] = {
56   0x00000078 /* 1 byte  */,
57   0x00000111 /* 2 bytes */,
58   0x00001234 /* 3 bytes */,
59   0x00040404 /* 4 bytes */,
60};
61
62/* This is the buffer for the converted bytes. */
63uint8_t buff[1000];  /* Large so we con'don't have to worry about it */
64
65void write_and_check(uint32_t *, unsigned, unsigned);
66
67
68static cu41_t
69do_cu41(uint8_t *dst, uint64_t dst_len, uint32_t *src, uint64_t src_len)
70{
71   int cc = 42;
72   cu41_t regs;
73
74   /* build up the register pairs */
75   register uint32_t *source     asm("4") = src;
76   register uint64_t  source_len asm("5") = src_len;
77   register uint8_t  *dest       asm("2") = dst;
78   register uint64_t  dest_len   asm("3") = dst_len;
79
80   asm volatile(
81                CU41(2,4)
82                "ipm %2\n\t"
83                "srl %2,28\n\t"
84                : "+d"(dest), "+d"(source), "=d"(cc),
85                  "+d"(source_len), "+d"(dest_len)
86                :
87                : "memory", "cc");
88
89   /* Capture register contents at end of cu41 */
90   regs.addr1 = (uint64_t)dest;
91   regs.len1  = dest_len;
92   regs.addr2 = (uint64_t)source;
93   regs.len2  = source_len;
94   regs.cc = cc;
95
96   return regs;
97}
98
99void
100run_test(uint8_t *dst, uint64_t dst_len, uint32_t *src, uint64_t src_len)
101{
102   int i;
103   cu41_t result;
104
105   result = do_cu41(dst, dst_len, src, src_len);
106
107   // Write out the converted values, if any
108   printf("UTF8: ");
109   if (dst_len - result.len1 == 0)
110      printf(" <none>");
111   else
112      for (i = 0; i < dst_len - result.len1; ++i) {
113         printf(" %02x", dst[i]);
114      }
115   printf("\n");
116
117   printf("  cc = %d\n", result.cc);
118   if (dst != NULL)
119      printf("  dst address difference: %"PRId64, result.addr1 - (uint64_t)dst);
120   printf("  dst len: %"PRId64"\n", result.len1);
121
122   if (src != NULL)
123      printf("  src address difference: %"PRId64, result.addr2 - (uint64_t)src);
124   printf("  src len: %"PRId64"\n", result.len2);
125}
126
127int main()
128{
129   int i;
130
131   /* Length == 0, no memory should be read or written */
132   printf("\n------------- test1 ----------------\n");
133   run_test(NULL, 0, NULL, 0);
134
135   /* Test exhaustion of source length (source bytes are valid) */
136   printf("\n------------- test2.1 ----------------\n");
137
138   /* No character will be written to BUFF, i.e. loop in jitted code
139      is not iterated */
140   run_test(buff, sizeof buff, NULL,     0);
141   run_test(buff, sizeof buff, NULL,     1);
142   run_test(buff, sizeof buff, NULL,     2);
143   run_test(buff, sizeof buff, NULL,     3);
144   run_test(buff, sizeof buff, pattern1, 0);
145   run_test(buff, sizeof buff, pattern1, 1);
146   run_test(buff, sizeof buff, pattern1, 2);
147   run_test(buff, sizeof buff, pattern1, 3);
148
149   printf("\n------------- test2.2 ----------------\n");
150   /* At least one character will be written to BUFF, i.e. loop in jitted
151      code is iterated */
152   run_test(buff, sizeof buff, pattern1, 4);  /* 1 utf32 -> 1 1-byte utf8 */
153   run_test(buff, sizeof buff, pattern2, 10); /* 2 utf32 -> 2 2-byte utf8 */
154   run_test(buff, sizeof buff, pattern3, 5);  /* 1 utf32 -> 1 3-byte utf8 */
155   run_test(buff, sizeof buff, pattern4, 21); /* 5 utf32 -> 5 4-byte utf8 */
156
157   /* Test exhaustion of destination length (source bytes are valid) */
158   printf("\n------------- test3.1 ----------------\n");
159
160   /* No character will be written to BUFF, i.e. loop in jitted code
161      is not iterated */
162
163   /* Want to write at least 1 byte */
164   run_test(NULL, 0, pattern1, sizeof pattern1);
165
166   /* Want to write at least 2 bytes */
167   run_test(NULL, 0, pattern2, sizeof pattern2);
168   run_test(NULL, 1, pattern2, sizeof pattern2);
169
170   /* Want to write at least 3 bytes */
171   run_test(NULL, 0, pattern3, sizeof pattern3);
172   run_test(NULL, 1, pattern3, sizeof pattern3);
173
174   /* Want to write at least 4 bytes */
175   run_test(NULL, 0, pattern4, sizeof pattern4);
176   run_test(NULL, 1, pattern4, sizeof pattern4);
177   run_test(NULL, 2, pattern4, sizeof pattern4);
178   run_test(NULL, 3, pattern4, sizeof pattern4);
179
180   /* When both operands are exhausted, cc=0 takes precedence.
181      (test1 tests this for len == 0) */
182   printf("\n------------- test4 ----------------\n");
183   run_test(buff, 2, pattern1, 8);
184
185   /* Input contains invalid characters */
186
187   // As conversion stops upon encountering an invalid character, we
188   // need to test each invalid character separately, to make sure it
189   // is recognized as invalid.
190
191   printf("\n------------- test5 ----------------\n");
192   for (i = 0; i < sizeof invalid / 4; ++i) {
193      run_test(buff, sizeof buff, invalid + i, 4);
194   }
195   run_test(buff, 0, invalid, sizeof invalid);  // cc = 2
196   run_test(buff, 100, invalid, sizeof invalid);
197
198   /* Convert all pattern buffers */
199   printf("\n------------- test6 ----------------\n");
200   run_test(buff, sizeof buff, pattern1, sizeof pattern1);
201   run_test(buff, sizeof buff, pattern2, sizeof pattern2);
202   run_test(buff, sizeof buff, pattern3, sizeof pattern3);
203   run_test(buff, sizeof buff, pattern4, sizeof pattern4);
204   run_test(buff, sizeof buff, mixed,    sizeof mixed);
205
206   /* Make sure we only write the exact number of bytes (and not more) */
207
208   /* Write 1 byte */
209   printf("\n------------- test7.0 ----------------\n");
210   write_and_check(pattern1 + 2, 4, 1);
211
212   /* Write 2 bytes */
213   printf("\n------------- test7.1 ----------------\n");
214   write_and_check(pattern2 + 3, 4, 2);
215
216   /* Write 3 bytes */
217   printf("\n------------- test7.2 ----------------\n");
218   write_and_check(pattern3 + 6, 4, 3);
219
220   /* Write 4 bytes */
221   printf("\n------------- test7.3 ----------------\n");
222   write_and_check(pattern4 + 5, 4, 4);
223
224   return 0;
225}
226
227
228void
229write_and_check_aux(uint32_t *input, unsigned num_input_bytes,
230                    unsigned num_expected_output_bytes,
231                    unsigned fill_byte)
232{
233   int num_errors, i;
234
235   /* Fill output buffer with FILL_BYTE */
236   memset(buff, fill_byte, sizeof buff);
237
238   /* Execute cu41 */
239   run_test(buff, sizeof buff, input, num_input_bytes);
240
241   /* Make sure the rest of the buffer is unmodified.  */
242   num_errors = 0;
243   for (i = num_expected_output_bytes; i < sizeof buff; ++i)
244      if (((unsigned char *)buff)[i] != fill_byte) ++num_errors;
245   if (num_errors)
246      fprintf(stderr, "*** wrote more than %d bytes\n",
247              num_expected_output_bytes);
248}
249
250void
251write_and_check(uint32_t *input, unsigned num_input_bytes,
252                unsigned num_expected_output_bytes)
253{
254   write_and_check_aux(input, num_input_bytes, num_expected_output_bytes, 0x0);
255
256   /* Run again with different fill pattern to make sure we did not write
257      an extra 0x0 byte */
258   write_and_check_aux(input, num_input_bytes, num_expected_output_bytes, 0xFF);
259}
260