ir_expression::ir_expression(int op, const struct glsl_type *type, ir_rvalue *op0, ir_rvalue *op1) { assert(((op1 == NULL) && (get_num_operands(ir_expression_operation(op)) == 1)) || (get_num_operands(ir_expression_operation(op)) == 2)); this->ir_type = ir_type_expression; this->type = type; this->operation = ir_expression_operation(op); this->operands[0] = op0; this->operands[1] = op1; this->operands[2] = NULL; this->operands[3] = NULL; }
/* Return a completely initialised control block */ IRICB new_iricb(const irop_t *op, test_data_t *data) { IRICB cb; cb.op = op->op; cb.result = (HWord)&data->result.value; cb.opnd1 = (HWord)&data->opnds[0].value; cb.opnd2 = (HWord)&data->opnds[1].value; cb.opnd3 = (HWord)&data->opnds[2].value; cb.opnd4 = (HWord)&data->opnds[3].value; cb.t_result = data->result.type; cb.t_opnd1 = data->opnds[0].type; cb.t_opnd2 = data->opnds[1].type; cb.t_opnd3 = data->opnds[2].type; cb.t_opnd4 = data->opnds[3].type; cb.rounding_mode = data->rounding_mode; cb.num_operands = get_num_operands(op->op); cb.immediate_index = op->immediate_index; cb.immediate_type = op->immediate_type; return cb; }
/* Execute the test under valgrind. Well, yes, we're not really executing it here, just preparing for it... */ void valgrind_execute_test(const irop_t *op, test_data_t *data) { unsigned i, num_operands; if (verbose > 2) printf("---------- Running a test\n"); num_operands = get_num_operands(op->op); for (i = 0; i < num_operands; ++i) { valgrind_set_vbits(&data->opnds[i]); if (verbose > 2) { printf("opnd #%u: ", i); print_opnd(stdout, &data->opnds[i]); printf("\n"); } } if (verbose > 2) if (data->rounding_mode != NO_ROUNDING_MODE) printf("rounding mode %u\n", data->rounding_mode); valgrind_vex_inject_ir(); valgrind_get_vbits(&data->result); if (verbose > 2) { printf("result: "); print_opnd(stdout, &data->result); printf("\n"); } }
ir_expression::ir_expression(int op, const struct glsl_type *type, ir_rvalue *op0) : ir_rvalue(precision_from_ir(op0)) { assert(get_num_operands(ir_expression_operation(op)) == 1); this->ir_type = ir_type_expression; this->type = type; this->operation = ir_expression_operation(op); this->operands[0] = op0; this->operands[1] = NULL; this->operands[2] = NULL; this->operands[3] = NULL; }
ir_expression::ir_expression(int op, const struct glsl_type *type, ir_rvalue *op0, ir_rvalue *op1, ir_rvalue *op2, ir_rvalue *op3) { this->ir_type = ir_type_expression; this->type = type; this->operation = ir_expression_operation(op); this->operands[0] = op0; this->operands[1] = op1; this->operands[2] = op2; this->operands[3] = op3; #ifndef NDEBUG int num_operands = get_num_operands(this->operation); for (int i = num_operands; i < 4; i++) { assert(this->operands[i] == NULL); } #endif }
/* Issue a complaint because the V-bits of the result of an operation differ from what was expected. */ void complain(const irop_t *op, const test_data_t *data, vbits_t expected) { fprintf(stderr, "*** Incorrect result for operator %s\n", op->name); int num_operands = get_num_operands(op->op); for (unsigned i = 0; i < num_operands; ++i) { fprintf(stderr, " opnd %u: ", i); print_opnd(stderr, &data->opnds[i]); fprintf(stderr, "\n"); } fprintf(stderr, " result: "); print_opnd(stderr, &data->result); fprintf(stderr, "\n"); fprintf(stderr, " expect: vbits = "); print_vbits(stderr, expected); fprintf(stderr, "\n"); }
bool ir_expression::equals(ir_instruction *ir) { const ir_expression *other = ir->as_expression(); if (!other) return false; if (type != other->type) return false; if (operation != other->operation) return false; for (unsigned i = 0; i < get_num_operands(); i++) { if (!operands[i]->equals(other->operands[i])) return false; } return true; }