From 3ca6fa7487b7f8f3576df8b9d5a52428a771eb80 Mon Sep 17 00:00:00 2001 From: Caio Oliveira Date: Fri, 6 Dec 2024 23:36:12 -0800 Subject: [PATCH] intel/brw: Gather brw_reg related implementations in brw_reg.cpp Reviewed-by: Lionel Landwerlin Part-of: --- src/intel/compiler/brw_fs.cpp | 50 ----- src/intel/compiler/brw_reg.cpp | 315 ++++++++++++++++++++++++++++++ src/intel/compiler/brw_shader.cpp | 256 ------------------------ src/intel/compiler/meson.build | 1 + 4 files changed, 316 insertions(+), 306 deletions(-) create mode 100644 src/intel/compiler/brw_reg.cpp diff --git a/src/intel/compiler/brw_fs.cpp b/src/intel/compiler/brw_fs.cpp index 82646c1875d..b7221049b44 100644 --- a/src/intel/compiler/brw_fs.cpp +++ b/src/intel/compiler/brw_fs.cpp @@ -412,56 +412,6 @@ fs_inst::can_change_types() const !src[1].abs && !src[1].negate && src[1].file != ATTR)); } -bool -brw_reg::equals(const brw_reg &r) const -{ - return brw_regs_equal(this, &r); -} - -bool -brw_reg::negative_equals(const brw_reg &r) const -{ - return brw_regs_negative_equal(this, &r); -} - -bool -brw_reg::is_contiguous() const -{ - switch (file) { - case ARF: - case FIXED_GRF: - return hstride == BRW_HORIZONTAL_STRIDE_1 && - vstride == width + hstride; - case VGRF: - case ATTR: - return stride == 1; - case UNIFORM: - case IMM: - case BAD_FILE: - return true; - } - - unreachable("Invalid register file"); -} - -unsigned -brw_reg::component_size(unsigned width) const -{ - if (file == ARF || file == FIXED_GRF) { - const unsigned w = MIN2(width, 1u << this->width); - const unsigned h = width >> this->width; - const unsigned vs = vstride ? 1 << (vstride - 1) : 0; - const unsigned hs = hstride ? 1 << (hstride - 1) : 0; - assert(w > 0); - /* Note this rounds up to next horizontal stride to be consistent with - * the VGRF case below. - */ - return ((MAX2(1, h) - 1) * vs + MAX2(w * hs, 1)) * brw_type_size_bytes(type); - } else { - return MAX2(width * stride, 1) * brw_type_size_bytes(type); - } -} - void fs_visitor::vfail(const char *format, va_list va) { diff --git a/src/intel/compiler/brw_reg.cpp b/src/intel/compiler/brw_reg.cpp new file mode 100644 index 00000000000..bcc91a4260b --- /dev/null +++ b/src/intel/compiler/brw_reg.cpp @@ -0,0 +1,315 @@ +/* + * Copyright © 2010 Intel Corporation + * SPDX-License-Identifier: MIT + */ + +#include + +#include "brw_reg.h" +#include "util/macros.h" + +bool +brw_reg_saturate_immediate(brw_reg *reg) +{ + union { + unsigned ud; + int d; + float f; + double df; + } imm, sat_imm = { 0 }; + + const unsigned size = brw_type_size_bytes(reg->type); + + /* We want to either do a 32-bit or 64-bit data copy, the type is otherwise + * irrelevant, so just check the size of the type and copy from/to an + * appropriately sized field. + */ + if (size < 8) + imm.ud = reg->ud; + else + imm.df = reg->df; + + switch (reg->type) { + case BRW_TYPE_UD: + case BRW_TYPE_D: + case BRW_TYPE_UW: + case BRW_TYPE_W: + case BRW_TYPE_UQ: + case BRW_TYPE_Q: + /* Nothing to do. */ + return false; + case BRW_TYPE_F: + sat_imm.f = SATURATE(imm.f); + break; + case BRW_TYPE_DF: + sat_imm.df = SATURATE(imm.df); + break; + case BRW_TYPE_UB: + case BRW_TYPE_B: + unreachable("no UB/B immediates"); + case BRW_TYPE_V: + case BRW_TYPE_UV: + case BRW_TYPE_VF: + unreachable("unimplemented: saturate vector immediate"); + case BRW_TYPE_HF: + unreachable("unimplemented: saturate HF immediate"); + default: + unreachable("invalid type"); + } + + if (size < 8) { + if (imm.ud != sat_imm.ud) { + reg->ud = sat_imm.ud; + return true; + } + } else { + if (imm.df != sat_imm.df) { + reg->df = sat_imm.df; + return true; + } + } + return false; +} + +bool +brw_reg_negate_immediate(brw_reg *reg) +{ + switch (reg->type) { + case BRW_TYPE_D: + case BRW_TYPE_UD: + reg->d = -reg->d; + return true; + case BRW_TYPE_W: + case BRW_TYPE_UW: { + uint16_t value = -(int16_t)reg->ud; + reg->ud = value | (uint32_t)value << 16; + return true; + } + case BRW_TYPE_F: + reg->f = -reg->f; + return true; + case BRW_TYPE_VF: + reg->ud ^= 0x80808080; + return true; + case BRW_TYPE_DF: + reg->df = -reg->df; + return true; + case BRW_TYPE_UQ: + case BRW_TYPE_Q: + reg->d64 = -reg->d64; + return true; + case BRW_TYPE_UB: + case BRW_TYPE_B: + unreachable("no UB/B immediates"); + case BRW_TYPE_UV: + case BRW_TYPE_V: + assert(!"unimplemented: negate UV/V immediate"); + case BRW_TYPE_HF: + reg->ud ^= 0x80008000; + return true; + default: + unreachable("invalid type"); + } + + return false; +} + +bool +brw_reg_abs_immediate(brw_reg *reg) +{ + switch (reg->type) { + case BRW_TYPE_D: + reg->d = abs(reg->d); + return true; + case BRW_TYPE_W: { + uint16_t value = abs((int16_t)reg->ud); + reg->ud = value | (uint32_t)value << 16; + return true; + } + case BRW_TYPE_F: + reg->f = fabsf(reg->f); + return true; + case BRW_TYPE_DF: + reg->df = fabs(reg->df); + return true; + case BRW_TYPE_VF: + reg->ud &= ~0x80808080; + return true; + case BRW_TYPE_Q: + reg->d64 = imaxabs(reg->d64); + return true; + case BRW_TYPE_UB: + case BRW_TYPE_B: + unreachable("no UB/B immediates"); + case BRW_TYPE_UQ: + case BRW_TYPE_UD: + case BRW_TYPE_UW: + case BRW_TYPE_UV: + /* Presumably the absolute value modifier on an unsigned source is a + * nop, but it would be nice to confirm. + */ + assert(!"unimplemented: abs unsigned immediate"); + case BRW_TYPE_V: + assert(!"unimplemented: abs V immediate"); + case BRW_TYPE_HF: + reg->ud &= ~0x80008000; + return true; + default: + unreachable("invalid type"); + } + + return false; +} + +bool +brw_reg::is_zero() const +{ + if (file != IMM) + return false; + + assert(brw_type_size_bytes(type) > 1); + + switch (type) { + case BRW_TYPE_HF: + assert((d & 0xffff) == ((d >> 16) & 0xffff)); + return (d & 0xffff) == 0 || (d & 0xffff) == 0x8000; + case BRW_TYPE_F: + return f == 0; + case BRW_TYPE_DF: + return df == 0; + case BRW_TYPE_W: + case BRW_TYPE_UW: + assert((d & 0xffff) == ((d >> 16) & 0xffff)); + return (d & 0xffff) == 0; + case BRW_TYPE_D: + case BRW_TYPE_UD: + return d == 0; + case BRW_TYPE_UQ: + case BRW_TYPE_Q: + return u64 == 0; + default: + return false; + } +} + +bool +brw_reg::is_one() const +{ + if (file != IMM) + return false; + + assert(brw_type_size_bytes(type) > 1); + + switch (type) { + case BRW_TYPE_HF: + assert((d & 0xffff) == ((d >> 16) & 0xffff)); + return (d & 0xffff) == 0x3c00; + case BRW_TYPE_F: + return f == 1.0f; + case BRW_TYPE_DF: + return df == 1.0; + case BRW_TYPE_W: + case BRW_TYPE_UW: + assert((d & 0xffff) == ((d >> 16) & 0xffff)); + return (d & 0xffff) == 1; + case BRW_TYPE_D: + case BRW_TYPE_UD: + return d == 1; + case BRW_TYPE_UQ: + case BRW_TYPE_Q: + return u64 == 1; + default: + return false; + } +} + +bool +brw_reg::is_negative_one() const +{ + if (file != IMM) + return false; + + assert(brw_type_size_bytes(type) > 1); + + switch (type) { + case BRW_TYPE_HF: + assert((d & 0xffff) == ((d >> 16) & 0xffff)); + return (d & 0xffff) == 0xbc00; + case BRW_TYPE_F: + return f == -1.0; + case BRW_TYPE_DF: + return df == -1.0; + case BRW_TYPE_W: + assert((d & 0xffff) == ((d >> 16) & 0xffff)); + return (d & 0xffff) == 0xffff; + case BRW_TYPE_D: + return d == -1; + case BRW_TYPE_Q: + return d64 == -1; + default: + return false; + } +} + +bool +brw_reg::is_null() const +{ + return file == ARF && nr == BRW_ARF_NULL; +} + +bool +brw_reg::is_accumulator() const +{ + return file == ARF && (nr & 0xF0) == BRW_ARF_ACCUMULATOR; +} + +bool +brw_reg::equals(const brw_reg &r) const +{ + return brw_regs_equal(this, &r); +} + +bool +brw_reg::negative_equals(const brw_reg &r) const +{ + return brw_regs_negative_equal(this, &r); +} + +bool +brw_reg::is_contiguous() const +{ + switch (file) { + case ARF: + case FIXED_GRF: + return hstride == BRW_HORIZONTAL_STRIDE_1 && + vstride == width + hstride; + case VGRF: + case ATTR: + return stride == 1; + case UNIFORM: + case IMM: + case BAD_FILE: + return true; + } + + unreachable("Invalid register file"); +} + +unsigned +brw_reg::component_size(unsigned width) const +{ + if (file == ARF || file == FIXED_GRF) { + const unsigned w = MIN2(width, 1u << this->width); + const unsigned h = width >> this->width; + const unsigned vs = vstride ? 1 << (vstride - 1) : 0; + const unsigned hs = hstride ? 1 << (hstride - 1) : 0; + assert(w > 0); + /* Note this rounds up to next horizontal stride to be consistent with + * the VGRF case below. + */ + return ((MAX2(1, h) - 1) * vs + MAX2(w * hs, 1)) * brw_type_size_bytes(type); + } else { + return MAX2(width * stride, 1) * brw_type_size_bytes(type); + } +} + diff --git a/src/intel/compiler/brw_shader.cpp b/src/intel/compiler/brw_shader.cpp index 8ea5f518c44..d8449e09906 100644 --- a/src/intel/compiler/brw_shader.cpp +++ b/src/intel/compiler/brw_shader.cpp @@ -25,262 +25,6 @@ #include "brw_fs.h" #include "util/macros.h" -bool -brw_reg_saturate_immediate(brw_reg *reg) -{ - union { - unsigned ud; - int d; - float f; - double df; - } imm, sat_imm = { 0 }; - - const unsigned size = brw_type_size_bytes(reg->type); - - /* We want to either do a 32-bit or 64-bit data copy, the type is otherwise - * irrelevant, so just check the size of the type and copy from/to an - * appropriately sized field. - */ - if (size < 8) - imm.ud = reg->ud; - else - imm.df = reg->df; - - switch (reg->type) { - case BRW_TYPE_UD: - case BRW_TYPE_D: - case BRW_TYPE_UW: - case BRW_TYPE_W: - case BRW_TYPE_UQ: - case BRW_TYPE_Q: - /* Nothing to do. */ - return false; - case BRW_TYPE_F: - sat_imm.f = SATURATE(imm.f); - break; - case BRW_TYPE_DF: - sat_imm.df = SATURATE(imm.df); - break; - case BRW_TYPE_UB: - case BRW_TYPE_B: - unreachable("no UB/B immediates"); - case BRW_TYPE_V: - case BRW_TYPE_UV: - case BRW_TYPE_VF: - unreachable("unimplemented: saturate vector immediate"); - case BRW_TYPE_HF: - unreachable("unimplemented: saturate HF immediate"); - default: - unreachable("invalid type"); - } - - if (size < 8) { - if (imm.ud != sat_imm.ud) { - reg->ud = sat_imm.ud; - return true; - } - } else { - if (imm.df != sat_imm.df) { - reg->df = sat_imm.df; - return true; - } - } - return false; -} - -bool -brw_reg_negate_immediate(brw_reg *reg) -{ - switch (reg->type) { - case BRW_TYPE_D: - case BRW_TYPE_UD: - reg->d = -reg->d; - return true; - case BRW_TYPE_W: - case BRW_TYPE_UW: { - uint16_t value = -(int16_t)reg->ud; - reg->ud = value | (uint32_t)value << 16; - return true; - } - case BRW_TYPE_F: - reg->f = -reg->f; - return true; - case BRW_TYPE_VF: - reg->ud ^= 0x80808080; - return true; - case BRW_TYPE_DF: - reg->df = -reg->df; - return true; - case BRW_TYPE_UQ: - case BRW_TYPE_Q: - reg->d64 = -reg->d64; - return true; - case BRW_TYPE_UB: - case BRW_TYPE_B: - unreachable("no UB/B immediates"); - case BRW_TYPE_UV: - case BRW_TYPE_V: - assert(!"unimplemented: negate UV/V immediate"); - case BRW_TYPE_HF: - reg->ud ^= 0x80008000; - return true; - default: - unreachable("invalid type"); - } - - return false; -} - -bool -brw_reg_abs_immediate(brw_reg *reg) -{ - switch (reg->type) { - case BRW_TYPE_D: - reg->d = abs(reg->d); - return true; - case BRW_TYPE_W: { - uint16_t value = abs((int16_t)reg->ud); - reg->ud = value | (uint32_t)value << 16; - return true; - } - case BRW_TYPE_F: - reg->f = fabsf(reg->f); - return true; - case BRW_TYPE_DF: - reg->df = fabs(reg->df); - return true; - case BRW_TYPE_VF: - reg->ud &= ~0x80808080; - return true; - case BRW_TYPE_Q: - reg->d64 = imaxabs(reg->d64); - return true; - case BRW_TYPE_UB: - case BRW_TYPE_B: - unreachable("no UB/B immediates"); - case BRW_TYPE_UQ: - case BRW_TYPE_UD: - case BRW_TYPE_UW: - case BRW_TYPE_UV: - /* Presumably the absolute value modifier on an unsigned source is a - * nop, but it would be nice to confirm. - */ - assert(!"unimplemented: abs unsigned immediate"); - case BRW_TYPE_V: - assert(!"unimplemented: abs V immediate"); - case BRW_TYPE_HF: - reg->ud &= ~0x80008000; - return true; - default: - unreachable("invalid type"); - } - - return false; -} - -bool -brw_reg::is_zero() const -{ - if (file != IMM) - return false; - - assert(brw_type_size_bytes(type) > 1); - - switch (type) { - case BRW_TYPE_HF: - assert((d & 0xffff) == ((d >> 16) & 0xffff)); - return (d & 0xffff) == 0 || (d & 0xffff) == 0x8000; - case BRW_TYPE_F: - return f == 0; - case BRW_TYPE_DF: - return df == 0; - case BRW_TYPE_W: - case BRW_TYPE_UW: - assert((d & 0xffff) == ((d >> 16) & 0xffff)); - return (d & 0xffff) == 0; - case BRW_TYPE_D: - case BRW_TYPE_UD: - return d == 0; - case BRW_TYPE_UQ: - case BRW_TYPE_Q: - return u64 == 0; - default: - return false; - } -} - -bool -brw_reg::is_one() const -{ - if (file != IMM) - return false; - - assert(brw_type_size_bytes(type) > 1); - - switch (type) { - case BRW_TYPE_HF: - assert((d & 0xffff) == ((d >> 16) & 0xffff)); - return (d & 0xffff) == 0x3c00; - case BRW_TYPE_F: - return f == 1.0f; - case BRW_TYPE_DF: - return df == 1.0; - case BRW_TYPE_W: - case BRW_TYPE_UW: - assert((d & 0xffff) == ((d >> 16) & 0xffff)); - return (d & 0xffff) == 1; - case BRW_TYPE_D: - case BRW_TYPE_UD: - return d == 1; - case BRW_TYPE_UQ: - case BRW_TYPE_Q: - return u64 == 1; - default: - return false; - } -} - -bool -brw_reg::is_negative_one() const -{ - if (file != IMM) - return false; - - assert(brw_type_size_bytes(type) > 1); - - switch (type) { - case BRW_TYPE_HF: - assert((d & 0xffff) == ((d >> 16) & 0xffff)); - return (d & 0xffff) == 0xbc00; - case BRW_TYPE_F: - return f == -1.0; - case BRW_TYPE_DF: - return df == -1.0; - case BRW_TYPE_W: - assert((d & 0xffff) == ((d >> 16) & 0xffff)); - return (d & 0xffff) == 0xffff; - case BRW_TYPE_D: - return d == -1; - case BRW_TYPE_Q: - return d64 == -1; - default: - return false; - } -} - -bool -brw_reg::is_null() const -{ - return file == ARF && nr == BRW_ARF_NULL; -} - - -bool -brw_reg::is_accumulator() const -{ - return file == ARF && (nr & 0xF0) == BRW_ARF_ACCUMULATOR; -} - bool fs_inst::is_commutative() const { diff --git a/src/intel/compiler/meson.build b/src/intel/compiler/meson.build index d7111b3b45e..4ba682aecb8 100644 --- a/src/intel/compiler/meson.build +++ b/src/intel/compiler/meson.build @@ -104,6 +104,7 @@ libintel_compiler_brw_files = files( 'brw_print.cpp', 'brw_prim.h', 'brw_private.h', + 'brw_reg.cpp', 'brw_reg.h', 'brw_reg_type.c', 'brw_reg_type.h',