/* -*- mode: C; c-basic-offset: 3; -*- */
/*
This file is part of MemCheck, a heavyweight Valgrind tool for
detecting memory errors.
Copyright (C) 2012-2015 Florian Krohm
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#include <assert.h> // assert
#include <stdio.h> // printf
#include <stdlib.h> // malloc
#include <string.h> // memset
#include "valgrind.h" // RUNNING_ON_VALGRIND
#include "vtest.h"
static test_data_t *
new_test_data(const irop_t *op)
{
test_data_t *data = malloc(sizeof *data);
memset(data, 0x0, sizeof *data); // initialise
/* Obtain the operand types and set them */
IRType t_dst, t1, t2, t3, t4;
typeof_primop(op->op, &t_dst, &t1, &t2, &t3, &t4);
assert(t_dst != Ity_INVALID);
assert(t1 != Ity_INVALID);
data->result.type = t_dst;
if (is_floating_point_op_with_rounding_mode(op->op)) {
data->opnds[0].type = t2;
data->opnds[1].type = t3;
data->opnds[2].type = t4;
data->opnds[3].type = Ity_INVALID;
} else {
data->opnds[0].type = t1;
data->opnds[1].type = t2;
data->opnds[2].type = t3;
data->opnds[3].type = t4;
}
/* Set the rounding mode if the operation requires one.
FIXME: We should iterate over all rounding modes. For that need
FIXME: to distinguish between binary and decimal floating point */
if (is_floating_point_op_with_rounding_mode(op->op)) {
// for now just pick one
data->rounding_mode = Irrm_NEAREST; // same as Irrm_DFP_NEAREST
} else {
data->rounding_mode = NO_ROUNDING_MODE;
}
return data;
}
int verbose = 0;
/* Certain IROps require special handling. */
static void
fixup_irops(void)
{
#ifdef __powerpc__
get_irop(Iop_ShlD64)->shift_amount_is_immediate = 1;
get_irop(Iop_ShrD64)->shift_amount_is_immediate = 1;
get_irop(Iop_ShlD128)->shift_amount_is_immediate = 1;
get_irop(Iop_ShrD128)->shift_amount_is_immediate = 1;
#endif
}
int
main(int argc, char *argv[])
{
assert(sizeof(long long) == 8);
int num_unary_tests = 0, num_binary_tests = 0;
int num_ternary_tests = 0, num_qernary_tests = 0;
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i], "-v") == 0) ++verbose;
else if (strcmp(argv[i], "--help") == 0) {
printf("\nvbit-test [ -v | --help ]\n");
printf("\n\t-v verbose mode; show number of tests\n");
printf("\n\t-v -v verbose mode; shows IROps being tested\n");
printf("\n\t-v -v -v verbose mode, extreme edition\n\n");
return 0;
} else {
printf("%s ? Nothing happens.\n", argv[i]);
return 1;
}
}
if (! RUNNING_ON_VALGRIND) {
fprintf(stderr, "*** This program needs to run under memcheck.\n");
return 1;
}
setbuf(stdout, NULL); // make stdout unbuffered
fixup_irops(); // determine need for special handling
// Iterate over all primops
IROp first = Iop_INVALID + 1;
IROp last = Iop_LAST;
IROp opkind;
if (0) { // overwrite for debugging
first = Iop_CasCmpEQ8; last = first + 1;
}
// Iterate over all IROps in the enum type. That is the only way to
// make sure the operator is tested on at least one platform.
// Loop assumes no holes in the enumerator values
for (opkind = first; opkind < last; ++opkind) {
const irop_t *op = get_irop(opkind);
if (op == NULL) continue;
if (op->undef_kind == UNDEF_UNKNOWN) {
fprintf(stderr, "...skipping %s; unknown undef propagation\n",
op->name);
continue;
}
test_data_t *data = new_test_data(op);
if (verbose > 1) printf("Testing operator %s\n", op->name);
IRICB iricb = new_iricb(op, data);
valgrind_vex_init_for_iri(&iricb);
switch (iricb.num_operands) {
case 1:
num_unary_tests += test_unary_op(op, data);
break;
case 2:
num_binary_tests += test_binary_op(op, data);
break;
case 3:
num_ternary_tests += test_ternary_op(op, data);
break;
case 4:
num_qernary_tests += test_qernary_op(op, data);
break;
default:
panic("operator not handled");
}
free(data);
}
if (verbose)
printf("\nvbit-test ran %d unary, %d binary, %d ternary and"
" %d qernary tests.\n\n",
num_unary_tests, num_binary_tests, num_ternary_tests,
num_qernary_tests);
return 0;
}