Commit f474e6a4 authored by Alyssa Rosenzweig's avatar Alyssa Rosenzweig 💜 Committed by Marge Bot
Browse files

pan/bi: Remove old IR helpers


Signed-off-by: Alyssa Rosenzweig's avatarAlyssa Rosenzweig <alyssa.rosenzweig@collabora.com>
Part-of: <mesa/mesa!8135>
parent e5ec0dc1
......@@ -29,11 +29,11 @@ bi_liveness_ins_update(uint16_t *live, bi_instr *ins, unsigned max)
{
/* live_in[s] = GEN[s] + (live_out[s] - KILL[s]) */
pan_liveness_kill(live, bi_get_node(ins->dest[0]), max, bi_writemask_new(ins));
pan_liveness_kill(live, bi_get_node(ins->dest[0]), max, bi_writemask(ins));
bi_foreach_src(ins, src) {
unsigned node = bi_get_node(ins->src[src]);
unsigned bytemask = bi_bytemask_of_read_components_new(ins, ins->src[src]);
unsigned bytemask = bi_bytemask_of_read_components(ins, ins->src[src]);
pan_liveness_gen(live, node, max, bytemask);
}
......
......@@ -49,7 +49,7 @@ bi_compute_interference(bi_context *ctx, struct lcra_state *l)
for (unsigned i = 1; i < l->node_count; ++i) {
if (live[i])
lcra_add_node_interference(l, bi_get_node(ins->dest[d]), bi_writemask_new(ins), i, live[i]);
lcra_add_node_interference(l, bi_get_node(ins->dest[d]), bi_writemask(ins), i, live[i]);
}
}
......@@ -214,7 +214,7 @@ bi_spill_dest(bi_builder *b, bi_index index, uint32_t offset,
ins->dest[0] = bi_temp(b->shader);
ins->no_spill = true;
unsigned newc = util_last_bit(bi_writemask_new(ins)) >> 2;
unsigned newc = util_last_bit(bi_writemask(ins)) >> 2;
*channels = MAX2(*channels, newc);
b->cursor = bi_after_instr(ins);
......
......@@ -26,42 +26,6 @@
#include "compiler.h"
/* Does an instruction respect clamps and source mods? Depend
* on the types involved */
bool
bi_has_clamp(bi_instruction *ins)
{
bool classy = bi_class_props[ins->type] & BI_MODS;
bool floaty = nir_alu_type_get_base_type(ins->dest_type) == nir_type_float;
return classy && floaty;
}
/* Have to check source for e.g. compares */
bool
bi_has_source_mods(bi_instruction *ins)
{
bool classy = bi_class_props[ins->type] & BI_MODS;
bool floaty = nir_alu_type_get_base_type(ins->src_types[0]) == nir_type_float;
return classy && floaty;
}
/* A source is swizzled if the op is swizzlable, in 8-bit or
* 16-bit mode, and the swizzled op. TODO: multi args */
bool
bi_is_src_swizzled(bi_instruction *ins, unsigned s)
{
bool classy = bi_class_props[ins->type] & BI_SWIZZLABLE;
bool small = nir_alu_type_get_type_size(ins->dest_type) < 32;
bool first = (s == 0); /* TODO: prop? */
return classy && small && first;
}
bool
bi_has_arg(bi_instr *ins, bi_index arg)
{
......@@ -76,23 +40,6 @@ bi_has_arg(bi_instr *ins, bi_index arg)
return false;
}
uint16_t
bi_from_bytemask(uint16_t bytemask, unsigned bytes)
{
unsigned value = 0;
for (unsigned c = 0, d = 0; c < 16; c += bytes, ++d) {
bool a = (bytemask & (1 << c)) != 0;
for (unsigned q = c; q < bytes; ++q)
assert(((bytemask & (1 << q)) != 0) == a);
value |= (a << d);
}
return value;
}
/* Precondition: valid 16-bit or 32-bit register format. Returns whether it is
* 32-bit. Note auto reads to 32-bit registers even if the memory format is
* 16-bit, so is considered as such here */
......@@ -136,38 +83,8 @@ bi_count_staging_registers(bi_instr *ins)
unreachable("Invalid sr_count");
}
unsigned
bi_get_component_count(bi_instruction *ins, signed src)
{
/* Discards and branches are oddball since they're not BI_VECTOR but no
* destination. So special case.. */
if (ins->type == BI_DISCARD || ins->type == BI_BRANCH)
return 1;
if (bi_class_props[ins->type] & BI_VECTOR) {
assert(ins->vector_channels);
return (src <= 0) ? ins->vector_channels : 1;
} else {
unsigned dest_bytes = nir_alu_type_get_type_size(ins->dest_type);
unsigned src_bytes = nir_alu_type_get_type_size(ins->src_types[MAX2(src, 0)]);
/* If there's either f32 on either end, it's only a single
* component, etc. */
unsigned bytes = src < 0 ? dest_bytes : src_bytes;
if (ins->type == BI_CONVERT)
bytes = MAX2(dest_bytes, src_bytes);
if (ins->type == BI_ATEST || ins->type == BI_SELECT)
return 1;
return MAX2(32 / bytes, 1);
}
}
uint16_t
bi_bytemask_of_read_components_new(bi_instr *ins, bi_index node)
bi_bytemask_of_read_components(bi_instr *ins, bi_index node)
{
uint16_t mask = 0x0;
bool reads_sr = bi_opcode_props[ins->op].sr_read;
......@@ -191,7 +108,7 @@ bi_bytemask_of_read_components_new(bi_instr *ins, bi_index node)
}
unsigned
bi_writemask_new(bi_instr *ins)
bi_writemask(bi_instr *ins)
{
/* Assume we write a scalar */
unsigned mask = 0xF;
......@@ -210,95 +127,3 @@ bi_writemask_new(bi_instr *ins)
unsigned shift = ins->dest[0].offset * 4; /* 32-bit words */
return (mask << shift);
}
uint16_t
bi_bytemask_of_read_components(bi_instruction *ins, unsigned node)
{
uint16_t mask = 0x0;
bi_foreach_src(ins, s) {
if (ins->src[s] != node) continue;
unsigned component_count = bi_get_component_count(ins, s);
nir_alu_type T = ins->src_types[s];
unsigned size = nir_alu_type_get_type_size(T);
unsigned bytes = size / 8;
unsigned cmask = (1 << bytes) - 1;
for (unsigned i = 0; i < component_count; ++i) {
unsigned c = ins->swizzle[s][i];
mask |= (cmask << (c * bytes));
}
}
return mask;
}
uint64_t
bi_get_immediate(bi_instruction *ins, unsigned index)
{
unsigned v = ins->src[index];
assert(v & BIR_INDEX_CONSTANT);
unsigned shift = v & ~BIR_INDEX_CONSTANT;
/* Don't invoke undefined behaviour on shift */
if (shift == 64)
return 0;
uint64_t shifted = ins->constant.u64 >> shift;
/* Mask off the accessed part */
unsigned sz = nir_alu_type_get_type_size(ins->src_types[index]);
if (sz == 64)
return shifted;
else
return shifted & ((1ull << sz) - 1);
}
bool
bi_writes_component(bi_instruction *ins, unsigned comp)
{
return comp < bi_get_component_count(ins, -1);
}
/* Determine effective writemask for RA/DCE, noting that we currently act
* per-register hence aligning. TODO: when real write masks are handled in
* packing (not for a while), update this routine, removing the align */
unsigned
bi_writemask(bi_instruction *ins)
{
nir_alu_type T = ins->dest_type;
unsigned size = nir_alu_type_get_type_size(T);
unsigned bytes_per_comp = size / 8;
unsigned components = bi_get_component_count(ins, -1);
unsigned bytes = ALIGN_POT(bytes_per_comp * components, 4);
unsigned mask = (1 << bytes) - 1;
unsigned shift = ins->dest_offset * 4; /* 32-bit words */
return (mask << shift);
}
/* Rewrites uses of an index. This is O(nc) to the program and number of
* uses, so combine lowering is effectively O(n^2). Better bookkeeping
* would bring down to linear if that's an issue. */
void
bi_rewrite_uses(bi_context *ctx,
unsigned old, unsigned oldc,
unsigned new, unsigned newc)
{
assert(newc >= oldc);
bi_foreach_instr_global(ctx, ins) {
bi_foreach_src(ins, s) {
if (ins->src[s] != old) continue;
for (unsigned i = 0; i < 16; ++i)
ins->swizzle[s][i] += (newc - oldc);
ins->src[s] = new;
}
}
}
......@@ -1061,19 +1061,9 @@ pan_next_block(pan_block *block)
/* BIR manipulation */
bool bi_has_clamp(bi_instruction *ins);
bool bi_has_source_mods(bi_instruction *ins);
bool bi_is_src_swizzled(bi_instruction *ins, unsigned s);
bool bi_has_arg(bi_instr *ins, bi_index arg);
uint16_t bi_from_bytemask(uint16_t bytemask, unsigned bytes);
unsigned bi_get_component_count(bi_instruction *ins, signed s);
uint16_t bi_bytemask_of_read_components(bi_instruction *ins, unsigned node);
uint64_t bi_get_immediate(bi_instruction *ins, unsigned index);
bool bi_writes_component(bi_instruction *ins, unsigned comp);
unsigned bi_writemask(bi_instruction *ins);
uint16_t bi_bytemask_of_read_components_new(bi_instr *ins, bi_index node);
unsigned bi_writemask_new(bi_instr *ins);
void bi_rewrite_uses(bi_context *ctx, unsigned old, unsigned oldc, unsigned new, unsigned newc);
uint16_t bi_bytemask_of_read_components(bi_instr *ins, bi_index node);
unsigned bi_writemask(bi_instr *ins);
void bi_print_instr(bi_instr *I, FILE *fp);
void bi_print_slots(bi_registers *regs, FILE *fp);
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment