none/tests/s390x/cu42.c

   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
  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
  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    }
 106    printf("\n");
 107
 108    printf("  cc = %d\n", result.cc);
 109    if (dst != NULL)
 110       printf("  dst address difference: %"PRId64, result.addr1 - (uint64_t)dst);
 111    printf("  dst len: %"PRId64"\n", result.len1);
 112
 113    if (src != NULL)
 114       printf("  src address difference: %"PRId64, result.addr2 - (uint64_t)src);
 115    printf("  src len: %"PRId64"\n", result.len2);
 116 }
 117
 118 int main()
 119 {
 120    int i;
 121
 122    /* Length == 0, no memory should be read or written */
 123    printf("\n------------- test1 ----------------\n");
 124    run_test(NULL, 0, NULL, 0);
 125
 126    /* Test exhaustion of source length (source bytes are valid) */
 127    printf("\n------------- test2.1 ----------------\n");
 128
 129    /* No character will be written to BUFF, i.e. loop in jitted code
 130       is not iterated */
 131    run_test(buff, sizeof buff, NULL,     0);
 132    run_test(buff, sizeof buff, NULL,     1);
 133    run_test(buff, sizeof buff, NULL,     2);
 134    run_test(buff, sizeof buff, NULL,     3);
 135    run_test(buff, sizeof buff, pattern2, 0);
 136    run_test(buff, sizeof buff, pattern2, 1);
 137    run_test(buff, sizeof buff, pattern2, 2);
 138    run_test(buff, sizeof buff, pattern2, 3);
 139
 140    printf("\n------------- test2.2 ----------------\n");
 141    /* At least one character will be written to BUFF, i.e. loop in jitted
 142       code is iterated */
 143    run_test(buff, sizeof buff, pattern2, 4);  /* 1 utf32 -> 1 utf16 */
 144    run_test(buff, sizeof buff, pattern2, 10); /* 2 utf32 -> 2 utf16 */
 145    run_test(buff, sizeof buff, pattern4, 5);  /* 1 utf32 -> 2 utf16 */
 146    run_test(buff, sizeof buff, pattern4, 11); /* 2 utf32 -> 4 utf16 */
 147    run_test(buff, sizeof buff, pattern4, 18); /* 4 utf32 -> 8 utf16 */
 148
 149    /* Test exhaustion of destination length (source bytes are valid) */
 150    printf("\n------------- test3.1 ----------------\n");
 151
 152    /* No character will be written to BUFF, i.e. loop in jitted code
 153       is not iterated */
 154
 155    /* Want to write at least 1 UTF-16 */
 156    run_test(NULL, 0, pattern2, sizeof pattern2);
 157
 158    /* Want to write at least 1 UTF-16 */
 159    run_test(NULL, 0, pattern2, sizeof pattern2);
 160    run_test(NULL, 1, pattern2, sizeof pattern2);
 161
 162    /* Want to write at least 2 UTF-16 */
 163    run_test(NULL, 0, pattern4, sizeof pattern4);
 164    run_test(NULL, 1, pattern4, sizeof pattern4);
 165    run_test(NULL, 2, pattern4, sizeof pattern4);
 166    run_test(NULL, 3, pattern4, sizeof pattern4);
 167
 168    /* When both operands are exhausted, cc=0 takes precedence.
 169       (test1 tests this for len == 0) */
 170    printf("\n------------- test4 ----------------\n");
 171    run_test(buff, 4, pattern2, 8);
 172
 173    /* Input contains invalid characters */
 174
 175    // As conversion stops upon encountering an invalid character, we
 176    // need to test each invalid character separately, to make sure it
 177    // is recognized as invalid.
 178
 179    printf("\n------------- test5 ----------------\n");
 180    for (i = 0; i < sizeof invalid / 4; ++i) {
 181       run_test(buff, sizeof buff, invalid + i, 4);
 182    }
 183    run_test(buff, 0, invalid, sizeof invalid);  // cc = 2
 184    run_test(buff, 100, invalid, sizeof invalid);
 185
 186    /* Convert all pattern buffers */
 187    printf("\n------------- test6 ----------------\n");
 188    run_test(buff, sizeof buff, pattern2, sizeof pattern2);
 189    run_test(buff, sizeof buff, pattern4, sizeof pattern4);
 190    run_test(buff, sizeof buff, mixed,    sizeof mixed);
 191
 192    /* Make sure we only write the exact number of bytes (and not more) */
 193
 194    /* Write 2 bytes */
 195    printf("\n------------- test7.1 ----------------\n");
 196    write_and_check(pattern2 + 3, 4, 2);
 197
 198    /* Write 4 bytes */
 199    printf("\n------------- test7.2 ----------------\n");
 200    write_and_check(pattern4 + 5, 4, 4);
 201
 202    return 0;
 203 }
 204
 205
 206 void
 207 write_and_check_aux(uint32_t *input, unsigned num_input_bytes,
 208                     unsigned num_expected_output_bytes,
 209                     unsigned fill_byte)
 210 {
 211    int num_errors, i;
 212
 213    /* Fill output buffer with FILL_BYTE */
 214    memset(buff, fill_byte, sizeof buff);
 215
 216    /* Execute cu42 */
 217    run_test(buff, sizeof buff, input, num_input_bytes);
 218
 219    /* Make sure the rest of the buffer is unmodified.  */
 220    num_errors = 0;
 221    for (i = num_expected_output_bytes; i < sizeof buff; ++i)
 222       if (((unsigned char *)buff)[i] != fill_byte) ++num_errors;
 223    if (num_errors)
 224       fprintf(stderr, "*** wrote more than %d bytes\n",
 225               num_expected_output_bytes);
 226 }
 227
 228 void
 229 write_and_check(uint32_t *input, unsigned num_input_bytes,
 230                 unsigned num_expected_output_bytes)
 231 {
 232    write_and_check_aux(input, num_input_bytes, num_expected_output_bytes, 0x0);
 233
 234    /* Run again with different fill pattern to make sure we did not write
 235       an extra 0x0 byte */
 236    write_and_check_aux(input, num_input_bytes, num_expected_output_bytes, 0xFF);
 237 }