← Back to branch summary

~bkerensa/ubuntu/raring/valgrind/merge-from-deb

« back to all changes in this revision

Viewing changes to none/tests/s390x/cu24_1.c

  • Committer: Benjamin Kerensa
  • Date: 2012-11-21 23:57:58 UTC
  • mfrom: (1.1.16)
  • Revision ID: bkerensa@ubuntu.com-20121121235758-bd1rv5uc5vzov2p6
Merge from debian unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
none/tests/s390x/cu24_1.c
 
1
#include <stdint.h>
 
2
#include <inttypes.h>
 
3
#include <stdlib.h>
 
4
#include <string.h>
 
5
#include <stdio.h>
 
6
#include "opcodes.h"
 
7
 
 
8
#ifndef M3
 
9
#define M3 0
 
10
#endif
 
11
 
 
12
/* The abstracted result of an CU24 insn */
 
13
typedef struct {
 
14
   uint64_t addr1;  // target
 
15
   uint64_t len1;
 
16
   uint64_t addr2;  // source
 
17
   uint64_t len2;
 
18
   uint32_t cc;
 
19
} cu24_t;
 
20
 
 
21
/* Define various input buffers. */
 
22
 
 
23
/* Single UTF-16 value */
 
24
uint16_t pattern1[] = {
 
25
   0x0000, 0xd7ff,    /* [0000 ... d7ff]  corner cases */
 
26
   0xdc00, 0xffff,    /* [dc00 ... ffff]  corner cases */
 
27
   0x0047, 0x0156, 0x1245, 0xa021, 0xfffe /* misc */
 
28
};
 
29
 
 
30
/* UTF-16 surrogate pair */
 
31
uint16_t pattern2[] = {
 
32
   0xd800, 0xdc00,    /* left  corner case */
 
33
   0xdbff, 0xdfff,    /* right corner case */
 
34
   0xdada, 0xdddd, 0xdeaf, 0xdcdc  /* misc */
 
35
};
 
36
 
 
37
/* Invalid low surrogate */
 
38
uint16_t invalid[] = { 0xd801, 0x0098 };
 
39
 
 
40
/* Mixed bytes */
 
41
uint16_t mixed[] = {
 
42
   0x0078,
 
43
   0x0200,
 
44
   0xffff,
 
45
   0xd800, 0xdc01,
 
46
   0xde00, 0xdd00,
 
47
   0xc0c0
 
48
};
 
49
 
 
50
/* This is the buffer for the converted bytes. */
 
51
uint32_t buff[1000];  /* Large so we con'don't have to worry about it */
 
52
 
 
53
 
 
54
static cu24_t
 
55
do_cu24(uint32_t *dst, uint64_t dst_len, uint16_t *src, uint64_t src_len)
 
56
{
 
57
   int cc = 42;
 
58
   cu24_t regs;
 
59
 
 
60
   /* build up the register pairs */
 
61
   register uint16_t *source     asm("4") = src;
 
62
   register uint64_t  source_len asm("5") = src_len;
 
63
   register uint32_t *dest       asm("2") = dst;
 
64
   register uint64_t  dest_len   asm("3") = dst_len;
 
65
 
 
66
   asm volatile(
 
67
                CU24(M3,2,4)
 
68
                "ipm %2\n\t"
 
69
                "srl %2,28\n\t"
 
70
                : "+d"(dest), "+d"(source), "=d"(cc),
 
71
                  "+d"(source_len), "+d"(dest_len)
 
72
                :
 
73
                : "memory", "cc");
 
74
 
 
75
   /* Capture register contents at end of cu24 */
 
76
   regs.addr1 = (uint64_t)dest;
 
77
   regs.len1  = dest_len;
 
78
   regs.addr2 = (uint64_t)source;
 
79
   regs.len2  = source_len;
 
80
   regs.cc = cc;
 
81
   
 
82
   return regs;
 
83
}
 
84
 
 
85
void
 
86
run_test(uint32_t *dst, uint64_t dst_len, uint16_t *src, uint64_t src_len)
 
87
{
 
88
   int i;
 
89
   cu24_t result;
 
90
 
 
91
   result = do_cu24(dst, dst_len, src, src_len);
 
92
 
 
93
   // Write out the converted byte, if any
 
94
   printf("UTF32: ");
 
95
   if (dst_len - result.len1 == 0)
 
96
      printf(" <none>");
 
97
   else {
 
98
      uint64_t num_bytes = dst_len - result.len1;
 
99
 
 
100
      /* The number of bytes that were written must be divisible by 4 */
 
101
      if (num_bytes % 4 != 0)
 
102
         fprintf(stderr, "*** number of bytes is not a multiple of 4\n");
 
103
 
 
104
      for (i = 0; i < num_bytes / 4; i++) {
 
105
         printf(" %02x", dst[i]);
 
106
      }
 
107
   }
 
108
   printf("\n");
 
109
 
 
110
   printf("  cc = %d\n", result.cc);
 
111
   if (dst != NULL)
 
112
      printf("  dst address difference: %"PRId64, result.addr1 - (uint64_t)dst);
 
113
   printf("  dst len: %"PRId64"\n", result.len1);
 
114
 
 
115
   if (src != NULL)
 
116
      printf("  src address difference: %"PRId64, result.addr2 - (uint64_t)src);
 
117
   printf("  src len: %"PRId64"\n", result.len2);
 
118
}
 
119
 
 
120
int main()
 
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,     1);
 
132
   run_test(buff, sizeof buff, pattern1, 1);
 
133
   run_test(buff, sizeof buff, pattern2, 1);
 
134
   run_test(buff, sizeof buff, pattern2, 2);
 
135
   run_test(buff, sizeof buff, pattern2, 3);
 
136
 
 
137
   printf("\n------------- test2.2 ----------------\n");
 
138
   /* At least one character will be written to BUFF, i.e. loop in jitted
 
139
      code is iterated */
 
140
   run_test(buff, sizeof buff, pattern1, 3);
 
141
   run_test(buff, sizeof buff, pattern1, 5);
 
142
   run_test(buff, sizeof buff, pattern2, 2);
 
143
   run_test(buff, sizeof buff, pattern2, 5);
 
144
   run_test(buff, sizeof buff, pattern2, 7);
 
145
 
 
146
   /* Test exhaustion of destination length (source bytes are valid) */
 
147
   printf("\n------------- test3.1 ----------------\n");
 
148
 
 
149
   /* No character will be written to BUFF, i.e. loop in jitted code
 
150
      is not iterated */
 
151
 
 
152
   /* Want to write 4 bytes at a time */
 
153
   run_test(NULL, 0, pattern1, sizeof pattern1);
 
154
   run_test(NULL, 1, pattern1, sizeof pattern1);
 
155
   run_test(NULL, 2, pattern1, sizeof pattern1);
 
156
   run_test(NULL, 3, pattern1, sizeof pattern1);
 
157
 
 
158
   printf("\n------------- test3.2 ----------------\n");
 
159
   /* At least one character will be written to BUFF, i.e. loop in jitted
 
160
      code is iterated */
 
161
   run_test(buff, 4, pattern1, sizeof pattern1);
 
162
   run_test(buff, 5, pattern1, sizeof pattern1);
 
163
   run_test(buff, 6, pattern1, sizeof pattern1);
 
164
   run_test(buff, 7, pattern1, sizeof pattern1);
 
165
 
 
166
   /* When both operands are exhausted, cc=0 takes precedence.
 
167
      (test1 tests this for len == 0) */
 
168
   printf("\n------------- test4 ----------------\n");
 
169
   run_test(buff, 4, pattern1, 2);   // no iteration
 
170
   run_test(buff, 8, pattern1, 4);   // iteration
 
171
 
 
172
   /* Input has invalid low surrogate. */
 
173
   printf("\n------------- test5 ----------------\n");
 
174
   run_test(buff, sizeof buff, invalid, sizeof invalid);
 
175
   run_test(buff, 0, invalid, sizeof invalid);
 
176
 
 
177
   /* Convert all pattern buffers */
 
178
   printf("\n------------- test6 ----------------\n");
 
179
   run_test(buff, sizeof buff, pattern1, sizeof pattern1);
 
180
   run_test(buff, sizeof buff, pattern2, sizeof pattern2);
 
181
 
 
182
   return 0;
 
183
}