fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-21 15:50:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

intel/fs: name sources for A64 opcodes

Browse source 
Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Reviewed-by: Caio Oliveira <caio.oliveira@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/13719>
This commit is contained in:
Lionel Landwerlin 2021-10-28 12:05:16 +03:00 • committed by Marge Bot
parent 23ce94ff7e
commit c199f44d17
3 changed files with 94 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
src/intel/compiler/brw_eu_defines.h
View file

@ -940,6 +940,17 @@ enum surface_logical_srcs {
SURFACE_LOGICAL_NUM_SRCS SURFACE_LOGICAL_NUM_SRCS
}; };
enum a64_logical_srcs {
/** Address the A64 message operates on */
A64_LOGICAL_ADDRESS,
/** Source for the operation (unused of LOAD ops) */
A64_LOGICAL_SRC,
/** Per-opcode immediate argument. Number of dwords, bit size, or atomic op. */
A64_LOGICAL_ARG,
A64_LOGICAL_NUM_SRCS
};
#ifdef __cplusplus #ifdef __cplusplus
/** /**
* Allow brw_urb_write_flags enums to be ORed together. * Allow brw_urb_write_flags enums to be ORed together.

16
src/intel/compiler/brw_fs.cpp
View file

@ -6074,13 +6074,13 @@ lower_lsc_a64_logical_send(const fs_builder &bld, fs_inst *inst)
const intel_device_info *devinfo = bld.shader->devinfo; const intel_device_info *devinfo = bld.shader->devinfo;
/* Get the logical send arguments. */ /* Get the logical send arguments. */
const fs_reg &addr = inst->src[0]; const fs_reg &addr = inst->src[A64_LOGICAL_ADDRESS];
const fs_reg &src = inst->src[1]; const fs_reg &src = inst->src[A64_LOGICAL_SRC];
const unsigned src_sz = type_sz(src.type); const unsigned src_sz = type_sz(src.type);
const unsigned src_comps = inst->components_read(1); const unsigned src_comps = inst->components_read(1);
assert(inst->src[2].file == IMM); assert(inst->src[A64_LOGICAL_ARG].file == IMM);
const unsigned arg = inst->src[2].ud; const unsigned arg = inst->src[A64_LOGICAL_ARG].ud;
const bool has_side_effects = inst->has_side_effects(); const bool has_side_effects = inst->has_side_effects();
/* If the surface message has side effects and we're a fragment shader, we /* If the surface message has side effects and we're a fragment shader, we
@ -6186,11 +6186,11 @@ lower_a64_logical_send(const fs_builder &bld, fs_inst *inst)
{ {
const intel_device_info *devinfo = bld.shader->devinfo; const intel_device_info *devinfo = bld.shader->devinfo;
const fs_reg &addr = inst->src[0]; const fs_reg &addr = inst->src[A64_LOGICAL_ADDRESS];
const fs_reg &src = inst->src[1]; const fs_reg &src = inst->src[A64_LOGICAL_SRC];
const unsigned src_comps = inst->components_read(1); const unsigned src_comps = inst->components_read(1);
assert(inst->src[2].file == IMM); assert(inst->src[A64_LOGICAL_ARG].file == IMM);
const unsigned arg = inst->src[2].ud; const unsigned arg = inst->src[A64_LOGICAL_ARG].ud;
const bool has_side_effects = inst->has_side_effects(); const bool has_side_effects = inst->has_side_effects();
/* If the surface message has side effects and we're a fragment shader, we /* If the surface message has side effects and we're a fragment shader, we

120
src/intel/compiler/brw_fs_nir.cpp
View file

@ -4789,45 +4789,55 @@ fs_visitor::nir_emit_intrinsic(const fs_builder &bld, nir_intrinsic_instr *instr
assert(nir_dest_bit_size(instr->dest) <= 32); assert(nir_dest_bit_size(instr->dest) <= 32);
assert(nir_intrinsic_align(instr) > 0); assert(nir_intrinsic_align(instr) > 0);
fs_reg srcs[A64_LOGICAL_NUM_SRCS];
srcs[A64_LOGICAL_ADDRESS] = get_nir_src(instr->src[0]);
srcs[A64_LOGICAL_SRC] = fs_reg(); /* No source data */
if (nir_dest_bit_size(instr->dest) == 32 && if (nir_dest_bit_size(instr->dest) == 32 &&
nir_intrinsic_align(instr) >= 4) { nir_intrinsic_align(instr) >= 4) {
assert(nir_dest_num_components(instr->dest) <= 4); assert(nir_dest_num_components(instr->dest) <= 4);
fs_inst *inst = bld.emit(SHADER_OPCODE_A64_UNTYPED_READ_LOGICAL,
dest, srcs[A64_LOGICAL_ARG] = brw_imm_ud(instr->num_components);
get_nir_src(instr->src[0]), /* Address */
fs_reg(), /* No source data */ fs_inst *inst =
brw_imm_ud(instr->num_components)); bld.emit(SHADER_OPCODE_A64_UNTYPED_READ_LOGICAL, dest,
srcs, A64_LOGICAL_NUM_SRCS);
inst->size_written = instr->num_components * inst->size_written = instr->num_components *
inst->dst.component_size(inst->exec_size); inst->dst.component_size(inst->exec_size);
} else { } else {
const unsigned bit_size = nir_dest_bit_size(instr->dest); const unsigned bit_size = nir_dest_bit_size(instr->dest);
assert(nir_dest_num_components(instr->dest) == 1); assert(nir_dest_num_components(instr->dest) == 1);
fs_reg tmp = bld.vgrf(BRW_REGISTER_TYPE_UD); fs_reg tmp = bld.vgrf(BRW_REGISTER_TYPE_UD);
bld.emit(SHADER_OPCODE_A64_BYTE_SCATTERED_READ_LOGICAL,
tmp, srcs[A64_LOGICAL_ARG] = brw_imm_ud(bit_size);
get_nir_src(instr->src[0]), /* Address */
fs_reg(), /* No source data */ bld.emit(SHADER_OPCODE_A64_BYTE_SCATTERED_READ_LOGICAL, tmp,
brw_imm_ud(bit_size)); srcs, A64_LOGICAL_NUM_SRCS);
bld.MOV(dest, subscript(tmp, dest.type, 0)); bld.MOV(dest, subscript(tmp, dest.type, 0));
} }
break; break;
} }
case nir_intrinsic_store_global: case nir_intrinsic_store_global: {
assert(devinfo->ver >= 8); assert(devinfo->ver >= 8);
assert(nir_src_bit_size(instr->src[0]) <= 32); assert(nir_src_bit_size(instr->src[0]) <= 32);
assert(nir_intrinsic_write_mask(instr) == assert(nir_intrinsic_write_mask(instr) ==
(1u << instr->num_components) - 1); (1u << instr->num_components) - 1);
assert(nir_intrinsic_align(instr) > 0); assert(nir_intrinsic_align(instr) > 0);
fs_reg srcs[A64_LOGICAL_NUM_SRCS];
srcs[A64_LOGICAL_ADDRESS] = get_nir_src(instr->src[1]);
if (nir_src_bit_size(instr->src[0]) == 32 && if (nir_src_bit_size(instr->src[0]) == 32 &&
nir_intrinsic_align(instr) >= 4) { nir_intrinsic_align(instr) >= 4) {
assert(nir_src_num_components(instr->src[0]) <= 4); assert(nir_src_num_components(instr->src[0]) <= 4);
bld.emit(SHADER_OPCODE_A64_UNTYPED_WRITE_LOGICAL,
fs_reg(), srcs[A64_LOGICAL_SRC] = get_nir_src(instr->src[0]); /* Data */
get_nir_src(instr->src[1]), /* Address */ srcs[A64_LOGICAL_ARG] = brw_imm_ud(instr->num_components);
get_nir_src(instr->src[0]), /* Data */
brw_imm_ud(instr->num_components)); bld.emit(SHADER_OPCODE_A64_UNTYPED_WRITE_LOGICAL, fs_reg(),
srcs, A64_LOGICAL_NUM_SRCS);
} else { } else {
assert(nir_src_num_components(instr->src[0]) == 1); assert(nir_src_num_components(instr->src[0]) == 1);
const unsigned bit_size = nir_src_bit_size(instr->src[0]); const unsigned bit_size = nir_src_bit_size(instr->src[0]);
@ -4835,13 +4845,15 @@ fs_visitor::nir_emit_intrinsic(const fs_builder &bld, nir_intrinsic_instr *instr
brw_reg_type_from_bit_size(bit_size, BRW_REGISTER_TYPE_UD); brw_reg_type_from_bit_size(bit_size, BRW_REGISTER_TYPE_UD);
fs_reg tmp = bld.vgrf(BRW_REGISTER_TYPE_UD); fs_reg tmp = bld.vgrf(BRW_REGISTER_TYPE_UD);
bld.MOV(tmp, retype(get_nir_src(instr->src[0]), data_type)); bld.MOV(tmp, retype(get_nir_src(instr->src[0]), data_type));
bld.emit(SHADER_OPCODE_A64_BYTE_SCATTERED_WRITE_LOGICAL,
fs_reg(), srcs[A64_LOGICAL_SRC] = tmp;
get_nir_src(instr->src[1]), /* Address */ srcs[A64_LOGICAL_ARG] = brw_imm_ud(nir_src_bit_size(instr->src[0]));
tmp, /* Data */
brw_imm_ud(nir_src_bit_size(instr->src[0]))); bld.emit(SHADER_OPCODE_A64_BYTE_SCATTERED_WRITE_LOGICAL, fs_reg(),
srcs, A64_LOGICAL_NUM_SRCS);
} }
break; break;
}
case nir_intrinsic_global_atomic_add: case nir_intrinsic_global_atomic_add:
case nir_intrinsic_global_atomic_imin: case nir_intrinsic_global_atomic_imin:
@ -4896,11 +4908,13 @@ fs_visitor::nir_emit_intrinsic(const fs_builder &bld, nir_intrinsic_instr *instr
mov->predicate_inverse = true; mov->predicate_inverse = true;
} }
fs_inst *load = ubld.emit(SHADER_OPCODE_A64_OWORD_BLOCK_READ_LOGICAL, fs_reg srcs[A64_LOGICAL_NUM_SRCS];
load_val, addr, srcs[A64_LOGICAL_ADDRESS] = addr;
fs_reg(), /* No source data */ srcs[A64_LOGICAL_SRC] = fs_reg(); /* No source data */
brw_imm_ud(instr->num_components)); srcs[A64_LOGICAL_ARG] = brw_imm_ud(instr->num_components);
fs_inst *load = ubld.emit(SHADER_OPCODE_A64_OWORD_BLOCK_READ_LOGICAL,
load_val, srcs, A64_LOGICAL_NUM_SRCS);
if (!is_pred_const) if (!is_pred_const)
load->predicate = BRW_PREDICATE_NORMAL; load->predicate = BRW_PREDICATE_NORMAL;
} }
@ -5597,11 +5611,14 @@ fs_visitor::nir_emit_intrinsic(const fs_builder &bld, nir_intrinsic_instr *instr
const unsigned block_bytes = block * 4; const unsigned block_bytes = block * 4;
const fs_builder &ubld = block == 8 ? ubld8 : ubld16; const fs_builder &ubld = block == 8 ? ubld8 : ubld16;
fs_reg srcs[A64_LOGICAL_NUM_SRCS];
srcs[A64_LOGICAL_ADDRESS] = address;
srcs[A64_LOGICAL_SRC] = fs_reg(); /* No source data */
srcs[A64_LOGICAL_ARG] = brw_imm_ud(block);
ubld.emit(SHADER_OPCODE_A64_UNALIGNED_OWORD_BLOCK_READ_LOGICAL, ubld.emit(SHADER_OPCODE_A64_UNALIGNED_OWORD_BLOCK_READ_LOGICAL,
retype(byte_offset(dest, loaded * 4), BRW_REGISTER_TYPE_UD), retype(byte_offset(dest, loaded * 4), BRW_REGISTER_TYPE_UD),
address, srcs, A64_LOGICAL_NUM_SRCS)->size_written = block_bytes;
fs_reg(), /* No source data */
brw_imm_ud(block))->size_written = block_bytes;
increment_a64_address(ubld1, address, block_bytes); increment_a64_address(ubld1, address, block_bytes);
loaded += block; loaded += block;
@ -5628,12 +5645,15 @@ fs_visitor::nir_emit_intrinsic(const fs_builder &bld, nir_intrinsic_instr *instr
const unsigned block = const unsigned block =
choose_oword_block_size_dwords(total - written); choose_oword_block_size_dwords(total - written);
fs_reg srcs[A64_LOGICAL_NUM_SRCS];
srcs[A64_LOGICAL_ADDRESS] = address;
srcs[A64_LOGICAL_SRC] = retype(byte_offset(src, written * 4),
BRW_REGISTER_TYPE_UD);
srcs[A64_LOGICAL_ARG] = brw_imm_ud(block);
const fs_builder &ubld = block == 8 ? ubld8 : ubld16; const fs_builder &ubld = block == 8 ? ubld8 : ubld16;
ubld.emit(SHADER_OPCODE_A64_OWORD_BLOCK_WRITE_LOGICAL, ubld.emit(SHADER_OPCODE_A64_OWORD_BLOCK_WRITE_LOGICAL, fs_reg(),
fs_reg(), srcs, A64_LOGICAL_NUM_SRCS);
address,
retype(byte_offset(src, written * 4), BRW_REGISTER_TYPE_UD),
brw_imm_ud(block));
const unsigned block_bytes = block * 4; const unsigned block_bytes = block * 4;
increment_a64_address(ubld1, address, block_bytes); increment_a64_address(ubld1, address, block_bytes);
@ -6030,21 +6050,26 @@ fs_visitor::nir_emit_global_atomic(const fs_builder &bld,
data = tmp; data = tmp;
} }
fs_reg srcs[A64_LOGICAL_NUM_SRCS];
srcs[A64_LOGICAL_ADDRESS] = addr;
srcs[A64_LOGICAL_SRC] = data;
srcs[A64_LOGICAL_ARG] = brw_imm_ud(op);
switch (nir_dest_bit_size(instr->dest)) { switch (nir_dest_bit_size(instr->dest)) {
case 16: { case 16: {
fs_reg dest32 = bld.vgrf(BRW_REGISTER_TYPE_UD); fs_reg dest32 = bld.vgrf(BRW_REGISTER_TYPE_UD);
bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_INT16_LOGICAL, bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_INT16_LOGICAL, dest32,
dest32, addr, data, brw_imm_ud(op)); srcs, A64_LOGICAL_NUM_SRCS);
bld.MOV(retype(dest, BRW_REGISTER_TYPE_UW), dest32); bld.MOV(retype(dest, BRW_REGISTER_TYPE_UW), dest32);
break; break;
} }
case 32: case 32:
bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_LOGICAL, bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_LOGICAL, dest,
dest, addr, data, brw_imm_ud(op)); srcs, A64_LOGICAL_NUM_SRCS);
break; break;
case 64: case 64:
bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_INT64_LOGICAL, bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_INT64_LOGICAL, dest,
dest, addr, data, brw_imm_ud(op)); srcs, A64_LOGICAL_NUM_SRCS);
break; break;
default: default:
unreachable("Unsupported bit size"); unreachable("Unsupported bit size");
@ -6073,21 +6098,26 @@ fs_visitor::nir_emit_global_atomic_float(const fs_builder &bld,
data = tmp; data = tmp;
} }
fs_reg srcs[A64_LOGICAL_NUM_SRCS];
srcs[A64_LOGICAL_ADDRESS] = addr;
srcs[A64_LOGICAL_SRC] = data;
srcs[A64_LOGICAL_ARG] = brw_imm_ud(op);
switch (nir_dest_bit_size(instr->dest)) { switch (nir_dest_bit_size(instr->dest)) {
case 16: { case 16: {
fs_reg dest32 = bld.vgrf(BRW_REGISTER_TYPE_UD); fs_reg dest32 = bld.vgrf(BRW_REGISTER_TYPE_UD);
bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_FLOAT16_LOGICAL, bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_FLOAT16_LOGICAL, dest32,
dest32, addr, data, brw_imm_ud(op)); srcs, A64_LOGICAL_NUM_SRCS);
bld.MOV(retype(dest, BRW_REGISTER_TYPE_UW), dest32); bld.MOV(retype(dest, BRW_REGISTER_TYPE_UW), dest32);
break; break;
} }
case 32: case 32:
bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_FLOAT32_LOGICAL, bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_FLOAT32_LOGICAL, dest,
dest, addr, data, brw_imm_ud(op)); srcs, A64_LOGICAL_NUM_SRCS);
break; break;
case 64: case 64:
bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_FLOAT64_LOGICAL, bld.emit(SHADER_OPCODE_A64_UNTYPED_ATOMIC_FLOAT64_LOGICAL, dest,
dest, addr, data, brw_imm_ud(op)); srcs, A64_LOGICAL_NUM_SRCS);
break; break;
default: default:
unreachable("Unsupported bit size"); unreachable("Unsupported bit size");