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 */ 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 } cu41_t; 17 18 /* Define various input buffers. */ 19 20 /* 0000 to 00ff: Result is 1 byte for each uint32_t */ 21 uint32_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 */ 27 uint32_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 */ 34 uint32_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 */ 41 uint32_t pattern4[] = { 42 0x10000, 0x10ffff, /* corner cases */ 43 0x10001, 0x10fffe, 0x12345, 0x23456, 0xfedcb /* misc */ 44 }; 45 46 /* Invalid UTF-32 character */ 47 uint32_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 */ 55 uint32_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. */ 63 uint8_t buff[1000]; /* Large so we con'don't have to worry about it */ 64 65 void write_and_check(uint32_t *, unsigned, unsigned); 66 67 68 static cu41_t 69 do_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 99 void 100 run_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 127 int 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 228 void 229 write_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 250 void 251 write_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
