← Back to branch summary

~ubuntu-branches/ubuntu/quantal/llvm-3.1/quantal

« back to all changes in this revision

Viewing changes to test/CodeGen/CellSPU/useful-harnesses/i64operations.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2012-03-29 19:09:51 UTC
  • Revision ID: package-import@ubuntu.com-20120329190951-aq83ivog4cg8bxun
Tags: upstream-3.1~svn153643
Import upstream version 3.1~svn153643

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/CodeGen/CellSPU/useful-harnesses/i64operations.c
 
1
#include <stdio.h>
 
2
#include "i64operations.h"
 
3
 
 
4
int64_t         tval_a = 1234567890003LL;
 
5
int64_t         tval_b = 2345678901235LL;
 
6
int64_t         tval_c = 1234567890001LL;
 
7
int64_t         tval_d = 10001LL;
 
8
int64_t         tval_e = 10000LL;
 
9
uint64_t        tval_f = 0xffffff0750135eb9;
 
10
int64_t         tval_g = -1;
 
11
 
 
12
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
 
13
 
 
14
int
 
15
i64_eq(int64_t a, int64_t b)
 
16
{
 
17
  return (a == b);
 
18
}
 
19
 
 
20
int
 
21
i64_neq(int64_t a, int64_t b)
 
22
{
 
23
  return (a != b);
 
24
}
 
25
 
 
26
int
 
27
i64_gt(int64_t a, int64_t b)
 
28
{
 
29
  return (a > b);
 
30
}
 
31
 
 
32
int
 
33
i64_le(int64_t a, int64_t b)
 
34
{
 
35
  return (a <= b);
 
36
}
 
37
 
 
38
int
 
39
i64_ge(int64_t a, int64_t b) {
 
40
  return (a >= b);
 
41
}
 
42
 
 
43
int
 
44
i64_lt(int64_t a, int64_t b) {
 
45
  return (a < b);
 
46
}
 
47
 
 
48
int
 
49
i64_uge(uint64_t a, uint64_t b)
 
50
{
 
51
  return (a >= b);
 
52
}
 
53
 
 
54
int
 
55
i64_ult(uint64_t a, uint64_t b)
 
56
{
 
57
  return (a < b);
 
58
}
 
59
 
 
60
int
 
61
i64_ugt(uint64_t a, uint64_t b)
 
62
{
 
63
  return (a > b);
 
64
}
 
65
 
 
66
int
 
67
i64_ule(uint64_t a, uint64_t b)
 
68
{
 
69
  return (a <= b);
 
70
}
 
71
 
 
72
int64_t
 
73
i64_eq_select(int64_t a, int64_t b, int64_t c, int64_t d)
 
74
{
 
75
  return ((a == b) ? c : d);
 
76
}
 
77
 
 
78
int64_t
 
79
i64_neq_select(int64_t a, int64_t b, int64_t c, int64_t d)
 
80
{
 
81
  return ((a != b) ? c : d);
 
82
}
 
83
 
 
84
int64_t
 
85
i64_gt_select(int64_t a, int64_t b, int64_t c, int64_t d) {
 
86
  return ((a > b) ? c : d);
 
87
}
 
88
 
 
89
int64_t
 
90
i64_le_select(int64_t a, int64_t b, int64_t c, int64_t d) {
 
91
  return ((a <= b) ? c : d);
 
92
}
 
93
 
 
94
int64_t
 
95
i64_ge_select(int64_t a, int64_t b, int64_t c, int64_t d) {
 
96
  return ((a >= b) ? c : d);
 
97
}
 
98
 
 
99
int64_t
 
100
i64_lt_select(int64_t a, int64_t b, int64_t c, int64_t d) {
 
101
  return ((a < b) ? c : d);
 
102
}
 
103
 
 
104
uint64_t
 
105
i64_ugt_select(uint64_t a, uint64_t b, uint64_t c, uint64_t d)
 
106
{
 
107
  return ((a > b) ? c : d);
 
108
}
 
109
 
 
110
uint64_t
 
111
i64_ule_select(uint64_t a, uint64_t b, uint64_t c, uint64_t d)
 
112
{
 
113
  return ((a <= b) ? c : d);
 
114
}
 
115
 
 
116
uint64_t
 
117
i64_uge_select(uint64_t a, uint64_t b, uint64_t c, uint64_t d) {
 
118
  return ((a >= b) ? c : d);
 
119
}
 
120
 
 
121
uint64_t
 
122
i64_ult_select(uint64_t a, uint64_t b, uint64_t c, uint64_t d) {
 
123
  return ((a < b) ? c : d);
 
124
}
 
125
 
 
126
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
 
127
 
 
128
struct harness_int64_pred int64_tests_eq[] = {
 
129
  {"a %s a", &tval_a, &tval_a, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
130
  {"a %s b", &tval_a, &tval_b, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
131
  {"a %s c", &tval_a, &tval_c, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
132
  {"d %s e", &tval_d, &tval_e, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
133
  {"e %s e", &tval_e, &tval_e, &tval_c, &tval_d, TRUE_VAL, &tval_c}
 
134
};
 
135
 
 
136
struct harness_int64_pred int64_tests_neq[] = {
 
137
  {"a %s a", &tval_a, &tval_a, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
138
  {"a %s b", &tval_a, &tval_b, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
139
  {"a %s c", &tval_a, &tval_c, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
140
  {"d %s e", &tval_d, &tval_e, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
141
  {"e %s e", &tval_e, &tval_e, &tval_c, &tval_d, FALSE_VAL, &tval_d}
 
142
};
 
143
 
 
144
struct harness_int64_pred int64_tests_sgt[] = {
 
145
  {"a %s a", &tval_a, &tval_a, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
146
  {"a %s b", &tval_a, &tval_b, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
147
  {"a %s c", &tval_a, &tval_c, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
148
  {"d %s e", &tval_d, &tval_e, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
149
  {"e %s e", &tval_e, &tval_e, &tval_c, &tval_d, FALSE_VAL, &tval_d}
 
150
};
 
151
 
 
152
struct harness_int64_pred int64_tests_sle[] = {
 
153
  {"a %s a", &tval_a, &tval_a, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
154
  {"a %s b", &tval_a, &tval_b, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
155
  {"a %s c", &tval_a, &tval_c, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
156
  {"d %s e", &tval_d, &tval_e, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
157
  {"e %s e", &tval_e, &tval_e, &tval_c, &tval_d, TRUE_VAL, &tval_c}
 
158
};
 
159
 
 
160
struct harness_int64_pred int64_tests_sge[] = {
 
161
  {"a %s a", &tval_a, &tval_a, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
162
  {"a %s b", &tval_a, &tval_b, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
163
  {"a %s c", &tval_a, &tval_c, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
164
  {"d %s e", &tval_d, &tval_e, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
165
  {"e %s e", &tval_e, &tval_e, &tval_c, &tval_d, TRUE_VAL, &tval_c}
 
166
};
 
167
 
 
168
struct harness_int64_pred int64_tests_slt[] = {
 
169
  {"a %s a", &tval_a, &tval_a, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
170
  {"a %s b", &tval_a, &tval_b, &tval_c, &tval_d, TRUE_VAL, &tval_c},
 
171
  {"a %s c", &tval_a, &tval_c, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
172
  {"d %s e", &tval_d, &tval_e, &tval_c, &tval_d, FALSE_VAL, &tval_d},
 
173
  {"e %s e", &tval_e, &tval_e, &tval_c, &tval_d, FALSE_VAL, &tval_d}
 
174
};
 
175
 
 
176
struct int64_pred_s int64_preds[] = {
 
177
  {"eq", i64_eq, i64_eq_select,
 
178
     int64_tests_eq, ARR_SIZE(int64_tests_eq)},
 
179
  {"neq", i64_neq, i64_neq_select,
 
180
     int64_tests_neq, ARR_SIZE(int64_tests_neq)},
 
181
  {"gt", i64_gt, i64_gt_select,
 
182
     int64_tests_sgt, ARR_SIZE(int64_tests_sgt)},
 
183
  {"le", i64_le, i64_le_select,
 
184
     int64_tests_sle, ARR_SIZE(int64_tests_sle)},
 
185
  {"ge", i64_ge, i64_ge_select,
 
186
     int64_tests_sge, ARR_SIZE(int64_tests_sge)},
 
187
  {"lt", i64_lt, i64_lt_select,
 
188
     int64_tests_slt, ARR_SIZE(int64_tests_slt)}
 
189
};
 
190
 
 
191
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
 
192
 
 
193
struct harness_uint64_pred uint64_tests_ugt[] = {
 
194
  {"a %s a", (uint64_t *) &tval_a, (uint64_t *) &tval_a, (uint64_t *) &tval_c,
 
195
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d},
 
196
  {"a %s b", (uint64_t *) &tval_a, (uint64_t *) &tval_b, (uint64_t *) &tval_c,
 
197
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d },
 
198
  {"a %s c", (uint64_t *) &tval_a, (uint64_t *) &tval_c, (uint64_t *) &tval_c,
 
199
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c },
 
200
  {"d %s e", (uint64_t *) &tval_d, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
201
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c },
 
202
  {"e %s e", (uint64_t *) &tval_e, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
203
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d }
 
204
};
 
205
 
 
206
struct harness_uint64_pred uint64_tests_ule[] = {
 
207
  {"a %s a", (uint64_t *) &tval_a, (uint64_t *) &tval_a, (uint64_t *) &tval_c,
 
208
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c},
 
209
  {"a %s b", (uint64_t *) &tval_a, (uint64_t *) &tval_b, (uint64_t *) &tval_c,
 
210
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c},
 
211
  {"a %s c", (uint64_t *) &tval_a, (uint64_t *) &tval_c, (uint64_t *) &tval_c,
 
212
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d},
 
213
  {"d %s e", (uint64_t *) &tval_d, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
214
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d},
 
215
  {"e %s e", (uint64_t *) &tval_e, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
216
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c}
 
217
};
 
218
 
 
219
struct harness_uint64_pred uint64_tests_uge[] = {
 
220
  {"a %s a", (uint64_t *) &tval_a, (uint64_t *) &tval_a, (uint64_t *) &tval_c,
 
221
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c},
 
222
  {"a %s b", (uint64_t *) &tval_a, (uint64_t *) &tval_b, (uint64_t *) &tval_c,
 
223
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d},
 
224
  {"a %s c", (uint64_t *) &tval_a, (uint64_t *) &tval_c, (uint64_t *) &tval_c,
 
225
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c},
 
226
  {"d %s e", (uint64_t *) &tval_d, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
227
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c},
 
228
  {"e %s e", (uint64_t *) &tval_e, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
229
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c}
 
230
};
 
231
 
 
232
struct harness_uint64_pred uint64_tests_ult[] = {
 
233
  {"a %s a", (uint64_t *) &tval_a, (uint64_t *) &tval_a, (uint64_t *) &tval_c,
 
234
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d},
 
235
  {"a %s b", (uint64_t *) &tval_a, (uint64_t *) &tval_b, (uint64_t *) &tval_c,
 
236
     (uint64_t *) &tval_d, TRUE_VAL, (uint64_t *) &tval_c},
 
237
  {"a %s c", (uint64_t *) &tval_a, (uint64_t *) &tval_c, (uint64_t *) &tval_c,
 
238
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d},
 
239
  {"d %s e", (uint64_t *) &tval_d, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
240
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d},
 
241
  {"e %s e", (uint64_t *) &tval_e, (uint64_t *) &tval_e, (uint64_t *) &tval_c,
 
242
     (uint64_t *) &tval_d, FALSE_VAL, (uint64_t *) &tval_d}
 
243
};
 
244
 
 
245
struct uint64_pred_s uint64_preds[] = {
 
246
  {"ugt", i64_ugt, i64_ugt_select,
 
247
     uint64_tests_ugt, ARR_SIZE(uint64_tests_ugt)},
 
248
  {"ule", i64_ule, i64_ule_select,
 
249
     uint64_tests_ule, ARR_SIZE(uint64_tests_ule)},
 
250
  {"uge", i64_uge, i64_uge_select,
 
251
     uint64_tests_uge, ARR_SIZE(uint64_tests_uge)},
 
252
  {"ult", i64_ult, i64_ult_select,
 
253
     uint64_tests_ult, ARR_SIZE(uint64_tests_ult)}
 
254
};
 
255
 
 
256
int
 
257
compare_expect_int64(const struct int64_pred_s * pred)
 
258
{
 
259
  int             j, failed = 0;
 
260
 
 
261
  for (j = 0; j < pred->n_tests; ++j) {
 
262
    int             pred_result;
 
263
 
 
264
    pred_result = (*pred->predfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs);
 
265
 
 
266
    if (pred_result != pred->tests[j].expected) {
 
267
      char            str[64];
 
268
 
 
269
      sprintf(str, pred->tests[j].fmt_string, pred->name);
 
270
      printf("%s: returned value is %d, expecting %d\n", str,
 
271
             pred_result, pred->tests[j].expected);
 
272
      printf("  lhs = %19lld (0x%016llx)\n", *pred->tests[j].lhs,
 
273
             *pred->tests[j].lhs);
 
274
      printf("  rhs = %19lld (0x%016llx)\n", *pred->tests[j].rhs,
 
275
             *pred->tests[j].rhs);
 
276
      ++failed;
 
277
    } else {
 
278
      int64_t         selresult;
 
279
 
 
280
      selresult = (pred->selfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs,
 
281
                                   *pred->tests[j].select_a,
 
282
                                   *pred->tests[j].select_b);
 
283
 
 
284
      if (selresult != *pred->tests[j].select_expected) {
 
285
        char            str[64];
 
286
 
 
287
        sprintf(str, pred->tests[j].fmt_string, pred->name);
 
288
        printf("%s select: returned value is %d, expecting %d\n", str,
 
289
               pred_result, pred->tests[j].expected);
 
290
        printf("  lhs   = %19lld (0x%016llx)\n", *pred->tests[j].lhs,
 
291
               *pred->tests[j].lhs);
 
292
        printf("  rhs   = %19lld (0x%016llx)\n", *pred->tests[j].rhs,
 
293
               *pred->tests[j].rhs);
 
294
        printf("  true  = %19lld (0x%016llx)\n", *pred->tests[j].select_a,
 
295
               *pred->tests[j].select_a);
 
296
        printf("  false = %19lld (0x%016llx)\n", *pred->tests[j].select_b,
 
297
               *pred->tests[j].select_b);
 
298
        ++failed;
 
299
      }
 
300
    }
 
301
  }
 
302
 
 
303
  printf("  %d tests performed, should be %d.\n", j, pred->n_tests);
 
304
 
 
305
  return failed;
 
306
}
 
307
 
 
308
int
 
309
compare_expect_uint64(const struct uint64_pred_s * pred)
 
310
{
 
311
  int             j, failed = 0;
 
312
 
 
313
  for (j = 0; j < pred->n_tests; ++j) {
 
314
    int             pred_result;
 
315
 
 
316
    pred_result = (*pred->predfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs);
 
317
    if (pred_result != pred->tests[j].expected) {
 
318
      char            str[64];
 
319
 
 
320
      sprintf(str, pred->tests[j].fmt_string, pred->name);
 
321
      printf("%s: returned value is %d, expecting %d\n", str,
 
322
             pred_result, pred->tests[j].expected);
 
323
      printf("  lhs = %19llu (0x%016llx)\n", *pred->tests[j].lhs,
 
324
             *pred->tests[j].lhs);
 
325
      printf("  rhs = %19llu (0x%016llx)\n", *pred->tests[j].rhs,
 
326
             *pred->tests[j].rhs);
 
327
      ++failed;
 
328
    } else {
 
329
      uint64_t        selresult;
 
330
 
 
331
      selresult = (pred->selfunc) (*pred->tests[j].lhs, *pred->tests[j].rhs,
 
332
                                   *pred->tests[j].select_a,
 
333
                                   *pred->tests[j].select_b);
 
334
      if (selresult != *pred->tests[j].select_expected) {
 
335
        char            str[64];
 
336
 
 
337
        sprintf(str, pred->tests[j].fmt_string, pred->name);
 
338
        printf("%s select: returned value is %d, expecting %d\n", str,
 
339
               pred_result, pred->tests[j].expected);
 
340
        printf("  lhs   = %19llu (0x%016llx)\n", *pred->tests[j].lhs,
 
341
               *pred->tests[j].lhs);
 
342
        printf("  rhs   = %19llu (0x%016llx)\n", *pred->tests[j].rhs,
 
343
               *pred->tests[j].rhs);
 
344
        printf("  true  = %19llu (0x%016llx)\n", *pred->tests[j].select_a,
 
345
               *pred->tests[j].select_a);
 
346
        printf("  false = %19llu (0x%016llx)\n", *pred->tests[j].select_b,
 
347
               *pred->tests[j].select_b);
 
348
        ++failed;
 
349
      }
 
350
    }
 
351
  }
 
352
 
 
353
  printf("  %d tests performed, should be %d.\n", j, pred->n_tests);
 
354
 
 
355
  return failed;
 
356
}
 
357
 
 
358
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
 
359
 
 
360
int
 
361
test_i64_sext_i32(int in, int64_t expected) {
 
362
  int64_t result = (int64_t) in;
 
363
 
 
364
  if (result != expected) {
 
365
    char str[64];
 
366
    sprintf(str, "i64_sext_i32(%d) returns %lld\n", in, result);
 
367
    return 1;
 
368
  }
 
369
 
 
370
  return 0;
 
371
}
 
372
 
 
373
int
 
374
test_i64_sext_i16(short in, int64_t expected) {
 
375
  int64_t result = (int64_t) in;
 
376
 
 
377
  if (result != expected) {
 
378
    char str[64];
 
379
    sprintf(str, "i64_sext_i16(%hd) returns %lld\n", in, result);
 
380
    return 1;
 
381
  }
 
382
 
 
383
  return 0;
 
384
}
 
385
 
 
386
int
 
387
test_i64_sext_i8(signed char in, int64_t expected) {
 
388
  int64_t result = (int64_t) in;
 
389
 
 
390
  if (result != expected) {
 
391
    char str[64];
 
392
    sprintf(str, "i64_sext_i8(%d) returns %lld\n", in, result);
 
393
    return 1;
 
394
  }
 
395
 
 
396
  return 0;
 
397
}
 
398
 
 
399
int
 
400
test_i64_zext_i32(unsigned int in, uint64_t expected) {
 
401
  uint64_t result = (uint64_t) in;
 
402
 
 
403
  if (result != expected) {
 
404
    char str[64];
 
405
    sprintf(str, "i64_zext_i32(%u) returns %llu\n", in, result);
 
406
    return 1;
 
407
  }
 
408
 
 
409
  return 0;
 
410
}
 
411
 
 
412
int
 
413
test_i64_zext_i16(unsigned short in, uint64_t expected) {
 
414
  uint64_t result = (uint64_t) in;
 
415
 
 
416
  if (result != expected) {
 
417
    char str[64];
 
418
    sprintf(str, "i64_zext_i16(%hu) returns %llu\n", in, result);
 
419
    return 1;
 
420
  }
 
421
 
 
422
  return 0;
 
423
}
 
424
 
 
425
int
 
426
test_i64_zext_i8(unsigned char in, uint64_t expected) {
 
427
  uint64_t result = (uint64_t) in;
 
428
 
 
429
  if (result != expected) {
 
430
    char str[64];
 
431
    sprintf(str, "i64_zext_i8(%u) returns %llu\n", in, result);
 
432
    return 1;
 
433
  }
 
434
 
 
435
  return 0;
 
436
}
 
437
 
 
438
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
 
439
 
 
440
int64_t
 
441
i64_shl_const(int64_t a) {
 
442
  return a << 10;
 
443
}
 
444
 
 
445
int64_t
 
446
i64_shl(int64_t a, int amt) {
 
447
  return a << amt;
 
448
}
 
449
 
 
450
uint64_t
 
451
u64_shl_const(uint64_t a) {
 
452
  return a << 10;
 
453
}
 
454
 
 
455
uint64_t
 
456
u64_shl(uint64_t a, int amt) {
 
457
  return a << amt;
 
458
}
 
459
 
 
460
int64_t
 
461
i64_srl_const(int64_t a) {
 
462
  return a >> 10;
 
463
}
 
464
 
 
465
int64_t
 
466
i64_srl(int64_t a, int amt) {
 
467
  return a >> amt;
 
468
}
 
469
 
 
470
uint64_t
 
471
u64_srl_const(uint64_t a) {
 
472
  return a >> 10;
 
473
}
 
474
 
 
475
uint64_t
 
476
u64_srl(uint64_t a, int amt) {
 
477
  return a >> amt;
 
478
}
 
479
 
 
480
int64_t
 
481
i64_sra_const(int64_t a) {
 
482
  return a >> 10;
 
483
}
 
484
 
 
485
int64_t
 
486
i64_sra(int64_t a, int amt) {
 
487
  return a >> amt;
 
488
}
 
489
 
 
490
uint64_t
 
491
u64_sra_const(uint64_t a) {
 
492
  return a >> 10;
 
493
}
 
494
 
 
495
uint64_t
 
496
u64_sra(uint64_t a, int amt) {
 
497
  return a >> amt;
 
498
}
 
499
 
 
500
int
 
501
test_u64_constant_shift(const char *func_name, uint64_t (*func)(uint64_t), uint64_t a, uint64_t expected) {
 
502
  uint64_t result = (*func)(a);
 
503
 
 
504
  if (result != expected) {
 
505
    printf("%s(0x%016llx) returns 0x%016llx, expected 0x%016llx\n", func_name, a, result, expected);
 
506
    return 1;
 
507
  }
 
508
 
 
509
  return 0;
 
510
}
 
511
 
 
512
int
 
513
test_i64_constant_shift(const char *func_name, int64_t (*func)(int64_t), int64_t a, int64_t expected) {
 
514
  int64_t result = (*func)(a);
 
515
 
 
516
  if (result != expected) {
 
517
    printf("%s(0x%016llx) returns 0x%016llx, expected 0x%016llx\n", func_name, a, result, expected);
 
518
    return 1;
 
519
  }
 
520
 
 
521
  return 0;
 
522
}
 
523
 
 
524
int
 
525
test_u64_variable_shift(const char *func_name, uint64_t (*func)(uint64_t, int), uint64_t a, unsigned int b, uint64_t expected) {
 
526
  uint64_t result = (*func)(a, b);
 
527
 
 
528
  if (result != expected) {
 
529
    printf("%s(0x%016llx, %d) returns 0x%016llx, expected 0x%016llx\n", func_name, a, b, result, expected);
 
530
    return 1;
 
531
  }
 
532
 
 
533
  return 0;
 
534
}
 
535
 
 
536
int
 
537
test_i64_variable_shift(const char *func_name, int64_t (*func)(int64_t, int), int64_t a, unsigned int b, int64_t expected) {
 
538
  int64_t result = (*func)(a, b);
 
539
 
 
540
  if (result != expected) {
 
541
    printf("%s(0x%016llx, %d) returns 0x%016llx, expected 0x%016llx\n", func_name, a, b, result, expected);
 
542
    return 1;
 
543
  }
 
544
 
 
545
  return 0;
 
546
}
 
547
 
 
548
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
 
549
 
 
550
int64_t i64_mul(int64_t a, int64_t b) {
 
551
  return a * b;
 
552
}
 
553
 
 
554
/* ~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~- */
 
555
 
 
556
int
 
557
main(void)
 
558
{
 
559
  int             i, j, failed = 0;
 
560
  const char     *something_failed = "  %d tests failed.\n";
 
561
  const char     *all_tests_passed = "  All tests passed.\n";
 
562
 
 
563
  printf("tval_a = %20lld (0x%016llx)\n", tval_a, tval_a);
 
564
  printf("tval_b = %20lld (0x%016llx)\n", tval_b, tval_b);
 
565
  printf("tval_c = %20lld (0x%016llx)\n", tval_c, tval_c);
 
566
  printf("tval_d = %20lld (0x%016llx)\n", tval_d, tval_d);
 
567
  printf("tval_e = %20lld (0x%016llx)\n", tval_e, tval_e);
 
568
  printf("tval_f = %20llu (0x%016llx)\n", tval_f, tval_f);
 
569
  printf("tval_g = %20llu (0x%016llx)\n", tval_g, tval_g);
 
570
  printf("----------------------------------------\n");
 
571
 
 
572
  for (i = 0; i < ARR_SIZE(int64_preds); ++i) {
 
573
    printf("%s series:\n", int64_preds[i].name);
 
574
    if ((failed = compare_expect_int64(int64_preds + i)) > 0) {
 
575
      printf(something_failed, failed);
 
576
    } else {
 
577
      printf(all_tests_passed);
 
578
    }
 
579
 
 
580
    printf("----------------------------------------\n");
 
581
  }
 
582
 
 
583
  for (i = 0; i < ARR_SIZE(uint64_preds); ++i) {
 
584
    printf("%s series:\n", uint64_preds[i].name);
 
585
    if ((failed = compare_expect_uint64(uint64_preds + i)) > 0) {
 
586
      printf(something_failed, failed);
 
587
    } else {
 
588
      printf(all_tests_passed);
 
589
    }
 
590
 
 
591
    printf("----------------------------------------\n");
 
592
  }
 
593
 
 
594
  /*----------------------------------------------------------------------*/
 
595
 
 
596
  puts("signed/zero-extend tests:");
 
597
 
 
598
  failed = 0;
 
599
  failed += test_i64_sext_i32(-1, -1LL);
 
600
  failed += test_i64_sext_i32(10, 10LL);
 
601
  failed += test_i64_sext_i32(0x7fffffff, 0x7fffffffLL);
 
602
  failed += test_i64_sext_i16(-1, -1LL);
 
603
  failed += test_i64_sext_i16(10, 10LL);
 
604
  failed += test_i64_sext_i16(0x7fff, 0x7fffLL);
 
605
  failed += test_i64_sext_i8(-1, -1LL);
 
606
  failed += test_i64_sext_i8(10, 10LL);
 
607
  failed += test_i64_sext_i8(0x7f, 0x7fLL);
 
608
 
 
609
  failed += test_i64_zext_i32(0xffffffff, 0x00000000ffffffffLLU);
 
610
  failed += test_i64_zext_i32(0x01234567, 0x0000000001234567LLU);
 
611
  failed += test_i64_zext_i16(0xffff,     0x000000000000ffffLLU);
 
612
  failed += test_i64_zext_i16(0x569a,     0x000000000000569aLLU);
 
613
  failed += test_i64_zext_i8(0xff,        0x00000000000000ffLLU);
 
614
  failed += test_i64_zext_i8(0xa0,        0x00000000000000a0LLU);
 
615
 
 
616
  if (failed > 0) {
 
617
    printf("  %d tests failed.\n", failed);
 
618
  } else {
 
619
    printf("  All tests passed.\n");
 
620
  }
 
621
 
 
622
  printf("----------------------------------------\n");
 
623
 
 
624
  failed = 0;
 
625
  puts("signed left/right shift tests:");
 
626
  failed += test_i64_constant_shift("i64_shl_const", i64_shl_const, tval_a,     0x00047dc7ec114c00LL);
 
627
  failed += test_i64_variable_shift("i64_shl",       i64_shl,       tval_a, 10, 0x00047dc7ec114c00LL);
 
628
  failed += test_i64_constant_shift("i64_srl_const", i64_srl_const, tval_a,     0x0000000047dc7ec1LL);
 
629
  failed += test_i64_variable_shift("i64_srl",       i64_srl,       tval_a, 10, 0x0000000047dc7ec1LL);
 
630
  failed += test_i64_constant_shift("i64_sra_const", i64_sra_const, tval_a,     0x0000000047dc7ec1LL);
 
631
  failed += test_i64_variable_shift("i64_sra",       i64_sra,       tval_a, 10, 0x0000000047dc7ec1LL);
 
632
 
 
633
  if (failed > 0) {
 
634
    printf("  %d tests ailed.\n", failed);
 
635
  } else {
 
636
    printf("  All tests passed.\n");
 
637
  }
 
638
 
 
639
  printf("----------------------------------------\n");
 
640
 
 
641
  failed = 0;
 
642
  puts("unsigned left/right shift tests:");
 
643
  failed += test_u64_constant_shift("u64_shl_const", u64_shl_const,  tval_f,     0xfffc1d404d7ae400LL);
 
644
  failed += test_u64_variable_shift("u64_shl",       u64_shl,        tval_f, 10, 0xfffc1d404d7ae400LL);
 
645
  failed += test_u64_constant_shift("u64_srl_const", u64_srl_const,  tval_f,     0x003fffffc1d404d7LL);
 
646
  failed += test_u64_variable_shift("u64_srl",       u64_srl,        tval_f, 10, 0x003fffffc1d404d7LL);
 
647
  failed += test_i64_constant_shift("i64_sra_const", i64_sra_const,  tval_f,     0xffffffffc1d404d7LL);
 
648
  failed += test_i64_variable_shift("i64_sra",       i64_sra,        tval_f, 10, 0xffffffffc1d404d7LL);
 
649
  failed += test_u64_constant_shift("u64_sra_const", u64_sra_const,  tval_f,     0x003fffffc1d404d7LL);
 
650
  failed += test_u64_variable_shift("u64_sra",       u64_sra,        tval_f, 10, 0x003fffffc1d404d7LL);
 
651
 
 
652
  if (failed > 0) {
 
653
    printf("  %d tests ailed.\n", failed);
 
654
  } else {
 
655
    printf("  All tests passed.\n");
 
656
  }
 
657
 
 
658
  printf("----------------------------------------\n");
 
659
 
 
660
  int64_t result;
 
661
  
 
662
  result = i64_mul(tval_g, tval_g);
 
663
  printf("%20lld * %20lld = %20lld (0x%016llx)\n", tval_g, tval_g, result, result);
 
664
  result = i64_mul(tval_d, tval_e);
 
665
  printf("%20lld * %20lld = %20lld (0x%016llx)\n", tval_d, tval_e, result, result);
 
666
  /* 0xba7a664f13077c9 */
 
667
  result = i64_mul(tval_a, tval_b);
 
668
  printf("%20lld * %20lld = %20lld (0x%016llx)\n", tval_a, tval_b, result, result);
 
669
 
 
670
  printf("----------------------------------------\n");
 
671
 
 
672
  return 0;
 
673
}