mirror of https://gitlab.freedesktop.org/mesa/mesa
174 lines
5.0 KiB
C
174 lines
5.0 KiB
C
/*
|
|
* Copyright (C) 2018-2019 Alyssa Rosenzweig <alyssa@rosenzweig.io>
|
|
* Copyright (C) 2019-2020 Collabora, Ltd.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include <inttypes.h>
|
|
#include <math.h>
|
|
#include "util/half_float.h"
|
|
#include "helpers.h"
|
|
#include "midgard.h"
|
|
#include "midgard_ops.h"
|
|
|
|
void
|
|
mir_print_constant_component(FILE *fp, const midgard_constants *consts,
|
|
unsigned c, midgard_reg_mode reg_mode, bool half,
|
|
unsigned mod, midgard_alu_op op)
|
|
{
|
|
bool is_sint = false, is_uint = false, is_hex = false;
|
|
const char *opname = alu_opcode_props[op].name;
|
|
|
|
bool is_int = midgard_is_integer_op(op);
|
|
|
|
/* Add a sentinel name to prevent crashing */
|
|
if (!opname)
|
|
opname = "unknown";
|
|
|
|
if (is_int) {
|
|
is_uint = midgard_is_unsigned_op(op);
|
|
|
|
if (!is_uint) {
|
|
/* Bit ops are easier to follow when the constant is printed in
|
|
* hexadecimal. Other operations starting with a 'i' are
|
|
* considered to operate on signed integers. That might not
|
|
* be true for all of them, but it's good enough for traces.
|
|
*/
|
|
if (op >= midgard_alu_op_iand && op <= midgard_alu_op_ipopcnt)
|
|
is_hex = true;
|
|
else
|
|
is_sint = true;
|
|
}
|
|
}
|
|
|
|
if (half)
|
|
reg_mode--;
|
|
|
|
switch (reg_mode) {
|
|
case midgard_reg_mode_64:
|
|
if (is_sint) {
|
|
fprintf(fp, "%" PRIi64, consts->i64[c]);
|
|
} else if (is_uint) {
|
|
fprintf(fp, "%" PRIu64, consts->u64[c]);
|
|
} else if (is_hex) {
|
|
fprintf(fp, "0x%" PRIX64, consts->u64[c]);
|
|
} else {
|
|
double v = consts->f64[c];
|
|
|
|
if (mod & MIDGARD_FLOAT_MOD_ABS)
|
|
v = fabs(v);
|
|
if (mod & MIDGARD_FLOAT_MOD_NEG)
|
|
v = -v;
|
|
|
|
printf("%g", v);
|
|
}
|
|
break;
|
|
|
|
case midgard_reg_mode_32:
|
|
if (is_sint) {
|
|
int64_t v;
|
|
|
|
if (half && mod == midgard_int_zero_extend)
|
|
v = consts->u32[c];
|
|
else if (half && mod == midgard_int_left_shift)
|
|
v = (uint64_t)consts->u32[c] << 32;
|
|
else
|
|
v = consts->i32[c];
|
|
|
|
fprintf(fp, "%" PRIi64, v);
|
|
} else if (is_uint || is_hex) {
|
|
uint64_t v;
|
|
|
|
if (half && mod == midgard_int_left_shift)
|
|
v = (uint64_t)consts->u32[c] << 32;
|
|
else
|
|
v = consts->u32[c];
|
|
|
|
fprintf(fp, is_uint ? "%" PRIu64 : "0x%" PRIX64, v);
|
|
} else {
|
|
float v = consts->f32[c];
|
|
|
|
if (mod & MIDGARD_FLOAT_MOD_ABS)
|
|
v = fabsf(v);
|
|
if (mod & MIDGARD_FLOAT_MOD_NEG)
|
|
v = -v;
|
|
|
|
fprintf(fp, "%g", v);
|
|
}
|
|
break;
|
|
|
|
case midgard_reg_mode_16:
|
|
if (is_sint) {
|
|
int32_t v;
|
|
|
|
if (half && mod == midgard_int_zero_extend)
|
|
v = consts->u16[c];
|
|
else if (half && mod == midgard_int_left_shift)
|
|
v = (uint32_t)consts->u16[c] << 16;
|
|
else
|
|
v = consts->i16[c];
|
|
|
|
fprintf(fp, "%d", v);
|
|
} else if (is_uint || is_hex) {
|
|
uint32_t v;
|
|
|
|
if (half && mod == midgard_int_left_shift)
|
|
v = (uint32_t)consts->u16[c] << 16;
|
|
else
|
|
v = consts->u16[c];
|
|
|
|
fprintf(fp, is_uint ? "%u" : "0x%X", v);
|
|
} else {
|
|
float v = _mesa_half_to_float(consts->f16[c]);
|
|
|
|
if (mod & MIDGARD_FLOAT_MOD_ABS)
|
|
v = fabsf(v);
|
|
if (mod & MIDGARD_FLOAT_MOD_NEG)
|
|
v = -v;
|
|
|
|
fprintf(fp, "%g", v);
|
|
}
|
|
break;
|
|
|
|
case midgard_reg_mode_8:
|
|
fprintf(fp, "0x%X", consts->u8[c]);
|
|
|
|
if (mod)
|
|
fprintf(fp, " /* %u */", mod);
|
|
|
|
assert(!half); /* No 4-bit */
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
static char *outmod_names_float[4] = {"", ".clamp_0_inf", ".clamp_m1_1",
|
|
".clamp_0_1"};
|
|
|
|
static char *outmod_names_int[4] = {".ssat", ".usat", ".keeplo", ".keephi"};
|
|
|
|
void
|
|
mir_print_outmod(FILE *fp, unsigned outmod, bool is_int)
|
|
{
|
|
fprintf(fp, "%s",
|
|
is_int ? outmod_names_int[outmod] : outmod_names_float[outmod]);
|
|
}
|