i965/fs: Replace fs_reg::subreg_offset with fs_reg::offset expressed in bytes.

The fs_reg::subreg_offset and ::offset fields are now redundant, the
sub-GRF offset can just be added to the single ::offset field
expressed in byte units.  The current subreg_offset value can be
recovered by applying the following rule: Replace each rvalue
reference of subreg_offset like 'x = r.subreg_offset' with 'x =
r.offset % reg_unit', and each lvalue reference like 'r.subreg_offset
= x' with 'r.offset = ROUND_DOWN_TO(r.offset, reg_unit) + x'.

For the same reason as in the previous patches, this doesn't attempt
to be particularly clever about simplifying the result in the interest
of keeping the rather lengthy patch as obvious as possible.  I'll come
back later to clean up any ugliness introduced here.

Reviewed-by: Iago Toral Quiroga <itoral@igalia.com>

diff --git a/src/mesa/drivers/dri/i965/brw_fs.cpp b/src/mesa/drivers/dri/i965/brw_fs.cpp
index 84017987b437702a0aa1fcf8f247db27911b154d..04f04572d8324f23a355015502dcecfe85f4134a 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_fs.cpp
+++ b/src/mesa/drivers/dri/i965/brw_fs.cpp
@@ -426,7 +426,6 @@ fs_reg::fs_reg(struct ::brw_reg reg) :
    backend_reg(reg)
 {
    this->offset = 0;
-   this->subreg_offset = 0;
    this->stride = 1;
    if (this->file == IMM &&
        (this->type != BRW_REGISTER_TYPE_V &&
@@ -440,7 +439,6 @@ bool
 fs_reg::equals(const fs_reg &r) const
 {
    return (this->backend_reg::equals(r) &&
-           subreg_offset == r.subreg_offset &&
            stride == r.stride);
 }
 
@@ -448,7 +446,7 @@ fs_reg &
 fs_reg::set_smear(unsigned subreg)
 {
    assert(file != ARF && file != FIXED_GRF && file != IMM);
-   subreg_offset = subreg * type_sz(type);
+   offset = ROUND_DOWN_TO(offset, REG_SIZE) + subreg * type_sz(type);
    stride = 0;
    return *this;
 }
@@ -710,7 +708,7 @@ fs_inst::is_partial_write() const
    return ((this->predicate && this->opcode != BRW_OPCODE_SEL) ||
            (this->exec_size * type_sz(this->dst.type)) < 32 ||
            !this->dst.is_contiguous() ||
-           this->dst.subreg_offset > 0);
+           this->dst.offset % REG_SIZE != 0);
 }
 
 unsigned
@@ -1485,7 +1483,7 @@ fs_visitor::assign_curb_setup()
             assert(inst->src[i].stride == 0);
             inst->src[i] = byte_offset(
                retype(brw_reg, inst->src[i].type),
-               inst->src[i].subreg_offset);
+               inst->src[i].offset % 4);
         }
       }
    }
@@ -1642,7 +1640,7 @@ fs_visitor::convert_attr_sources_to_hw_regs(fs_inst *inst)
          unsigned width = inst->src[i].stride == 0 ? 1 : exec_size;
          struct brw_reg reg =
             stride(byte_offset(retype(brw_vec8_grf(grf, 0), inst->src[i].type),
-                               inst->src[i].subreg_offset),
+                               inst->src[i].offset % REG_SIZE),
                    exec_size * inst->src[i].stride,
                    width, inst->src[i].stride);
          reg.abs = inst->src[i].abs;
@@ -2715,7 +2713,7 @@ fs_visitor::compute_to_mrf()
          inst->dst.type != inst->src[0].type ||
          inst->src[0].abs || inst->src[0].negate ||
           !inst->src[0].is_contiguous() ||
-          inst->src[0].subreg_offset)
+          inst->src[0].offset % REG_SIZE != 0)
         continue;
 
       /* Can't compute-to-MRF this GRF if someone else was going to
@@ -3519,7 +3517,7 @@ fs_visitor::lower_integer_multiplication()
                      assert(src1_1_w.stride == 1);
                      src1_1_w.stride = 2;
                   }
-                  src1_1_w.subreg_offset += type_sz(BRW_REGISTER_TYPE_UW);
+                  src1_1_w.offset += type_sz(BRW_REGISTER_TYPE_UW);
                }
                ibld.MUL(low, inst->src[0], src1_0_w);
                ibld.MUL(high, inst->src[0], src1_1_w);
@@ -3538,7 +3536,7 @@ fs_visitor::lower_integer_multiplication()
                   assert(src0_1_w.stride == 1);
                   src0_1_w.stride = 2;
                }
-               src0_1_w.subreg_offset += type_sz(BRW_REGISTER_TYPE_UW);
+               src0_1_w.offset += type_sz(BRW_REGISTER_TYPE_UW);
 
                ibld.MUL(low, src0_0_w, inst->src[1]);
                ibld.MUL(high, src0_1_w, inst->src[1]);
@@ -3546,14 +3544,14 @@ fs_visitor::lower_integer_multiplication()
 
             fs_reg dst = inst->dst;
             dst.type = BRW_REGISTER_TYPE_UW;
-            dst.subreg_offset = 2;
+            dst.offset = ROUND_DOWN_TO(dst.offset, REG_SIZE) + 2;
             dst.stride = 2;
 
             high.type = BRW_REGISTER_TYPE_UW;
             high.stride = 2;
 
             low.type = BRW_REGISTER_TYPE_UW;
-            low.subreg_offset = 2;
+            low.offset = ROUND_DOWN_TO(low.offset, REG_SIZE) + 2;
             low.stride = 2;
 
             ibld.ADD(dst, low, high);
@@ -5317,9 +5315,9 @@ fs_visitor::dump_instruction(backend_instruction *be_inst, FILE *file)
    case VGRF:
       fprintf(file, "vgrf%d", inst->dst.nr);
       if (alloc.sizes[inst->dst.nr] != inst->regs_written ||
-          inst->dst.subreg_offset)
+          inst->dst.offset % REG_SIZE)
          fprintf(file, "+%d.%d",
-                 inst->dst.offset / REG_SIZE, inst->dst.subreg_offset);
+                 inst->dst.offset / REG_SIZE, inst->dst.offset % REG_SIZE);
       break;
    case FIXED_GRF:
       fprintf(file, "g%d", inst->dst.nr);
@@ -5373,9 +5371,9 @@ fs_visitor::dump_instruction(backend_instruction *be_inst, FILE *file)
       case VGRF:
          fprintf(file, "vgrf%d", inst->src[i].nr);
          if (alloc.sizes[inst->src[i].nr] != (unsigned)inst->regs_read(i) ||
-             inst->src[i].subreg_offset)
+             inst->src[i].offset % REG_SIZE != 0)
             fprintf(file, "+%d.%d", inst->src[i].offset / REG_SIZE,
-                    inst->src[i].subreg_offset);
+                    inst->src[i].offset % REG_SIZE);
          break;
       case FIXED_GRF:
          fprintf(file, "g%d", inst->src[i].nr);
@@ -5388,9 +5386,9 @@ fs_visitor::dump_instruction(backend_instruction *be_inst, FILE *file)
          break;
       case UNIFORM:
          fprintf(file, "u%d", inst->src[i].nr + inst->src[i].offset / 4);
-         if (inst->src[i].subreg_offset) {
+         if (inst->src[i].offset % 4 != 0) {
             fprintf(file, "+%d.%d", inst->src[i].offset / 4,
-                    inst->src[i].subreg_offset);
+                    inst->src[i].offset % 4);
          }
          break;
       case BAD_FILE:

diff --git a/src/mesa/drivers/dri/i965/brw_fs_combine_constants.cpp b/src/mesa/drivers/dri/i965/brw_fs_combine_constants.cpp
index 5c1a00141ab2f5908522d506e16bf39adfbba374..fcf2fe2f1e4c668e172c0adab391d6fa1391a41d 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_fs_combine_constants.cpp
+++ b/src/mesa/drivers/dri/i965/brw_fs_combine_constants.cpp
@@ -280,12 +280,12 @@ fs_visitor::opt_combine_constants()
 
       ibld.MOV(reg, brw_imm_f(imm->val));
       imm->nr = reg.nr;
-      imm->subreg_offset = reg.subreg_offset;
+      imm->subreg_offset = reg.offset % REG_SIZE;
 
-      reg.subreg_offset += sizeof(float);
-      if ((unsigned)reg.subreg_offset == 8 * sizeof(float)) {
+      reg.offset += sizeof(float);
+      if (reg.offset == 8 * sizeof(float)) {
          reg.nr = alloc.allocate(1);
-         reg.subreg_offset = 0;
+         reg.offset = 0;
       }
    }
    promoted_constants = table.len;
@@ -296,7 +296,7 @@ fs_visitor::opt_combine_constants()
          fs_reg *reg = link->reg;
          reg->file = VGRF;
          reg->nr = table.imm[i].nr;
-         reg->subreg_offset = table.imm[i].subreg_offset;
+         reg->offset = table.imm[i].subreg_offset;
          reg->stride = 0;
          reg->negate = signbit(reg->f) != signbit(table.imm[i].val);
          assert((isnan(reg->f) && isnan(table.imm[i].val)) ||

diff --git a/src/mesa/drivers/dri/i965/brw_fs_copy_propagation.cpp b/src/mesa/drivers/dri/i965/brw_fs_copy_propagation.cpp
index 09d0a4ec985d599c7bc38b40e678ded89e89bbb0..10f0a5b282003f068a944a3c3df694191da54833 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_fs_copy_propagation.cpp
+++ b/src/mesa/drivers/dri/i965/brw_fs_copy_propagation.cpp
@@ -341,7 +341,7 @@ region_contained_in(const fs_reg &src, unsigned regs_read,
                     const fs_reg &dst, unsigned regs_written)
 {
    return src.file == dst.file && src.nr == dst.nr &&
-      (src.offset + src.subreg_offset >= dst.offset + dst.subreg_offset) &&
+          src.offset >= dst.offset &&
       src.offset / REG_SIZE + regs_read <= dst.offset / REG_SIZE + regs_written;
 }
 
@@ -461,30 +461,21 @@ fs_visitor::try_copy_propagate(fs_inst *inst, int arg, acp_entry *entry)
    inst->saturate = inst->saturate || entry->saturate;
 
    /* Compute the offset of inst->src[arg] relative to entry->dst */
-   const unsigned rel_offset = inst->src[arg].offset - entry->dst.offset +
-                               inst->src[arg].subreg_offset;
+   const unsigned rel_offset = inst->src[arg].offset - entry->dst.offset;
 
    /* Compute the first component of the copy that the instruction is
     * reading, and the base byte offset within that component.
     */
-   assert(entry->dst.subreg_offset == 0 && entry->dst.stride == 1);
+   assert(entry->dst.offset % REG_SIZE == 0 && entry->dst.stride == 1);
    const unsigned component = rel_offset / type_sz(entry->dst.type);
    const unsigned suboffset = rel_offset % type_sz(entry->dst.type);
 
-   /* Account for the inconsistent units reg_offset is expressed in.
-    * FINISHME -- Make the units of reg_offset consistent (e.g. bytes?) for
-    *             all register files.
-    */
-   const unsigned reg_size = (entry->src.file == UNIFORM ? 4 : REG_SIZE);
-
    /* Calculate the byte offset at the origin of the copy of the given
     * component and suboffset.
     */
-   const unsigned offset = suboffset +
+   inst->src[arg].offset = suboffset +
       component * entry->src.stride * type_sz(entry->src.type) +
-      entry->src.offset + entry->src.subreg_offset;
-   inst->src[arg].offset = ROUND_DOWN_TO(offset, reg_size);
-   inst->src[arg].subreg_offset = offset % reg_size;
+      entry->src.offset;
 
    if (has_source_modifiers) {
       if (entry->dst.type != inst->src[arg].type) {

diff --git a/src/mesa/drivers/dri/i965/brw_fs_generator.cpp b/src/mesa/drivers/dri/i965/brw_fs_generator.cpp
index 2a45c37022e0692b1b5576043fdd40a03e21ec2b..12ab7b3fe6639a8d28345fa6f15ff42543b28168 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_fs_generator.cpp
+++ b/src/mesa/drivers/dri/i965/brw_fs_generator.cpp
@@ -97,14 +97,14 @@ brw_reg_from_fs_reg(fs_inst *inst, fs_reg *reg, unsigned gen, bool compressed)
       }
 
       brw_reg = retype(brw_reg, reg->type);
-      brw_reg = byte_offset(brw_reg, reg->subreg_offset);
+      brw_reg = byte_offset(brw_reg, reg->offset % REG_SIZE);
       brw_reg.abs = reg->abs;
       brw_reg.negate = reg->negate;
       break;
    case ARF:
    case FIXED_GRF:
    case IMM:
-      assert(reg->subreg_offset == 0);
+      assert(reg->offset % REG_SIZE == 0);
       brw_reg = reg->as_brw_reg();
       break;
    case BAD_FILE:

diff --git a/src/mesa/drivers/dri/i965/brw_fs_nir.cpp b/src/mesa/drivers/dri/i965/brw_fs_nir.cpp
index a0d318767c7ce24c635468434b8361c28201dbed..cd4005c0e60fc82067039e53151662b4ae8be178 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_fs_nir.cpp
+++ b/src/mesa/drivers/dri/i965/brw_fs_nir.cpp
@@ -509,13 +509,13 @@ fs_visitor::optimize_frontfacing_ternary(nir_alu_instr *instr,
       }
 
       tmp.type = BRW_REGISTER_TYPE_W;
-      tmp.subreg_offset = 2;
+      tmp.offset = ROUND_DOWN_TO(tmp.offset, REG_SIZE) + 2;
       tmp.stride = 2;
 
       bld.OR(tmp, g0, brw_imm_uw(0x3f80));
 
       tmp.type = BRW_REGISTER_TYPE_D;
-      tmp.subreg_offset = 0;
+      tmp.offset = ROUND_DOWN_TO(tmp.offset, REG_SIZE);
       tmp.stride = 1;
    } else {
       /* Bit 31 of g1.6 is 0 if the polygon is front facing. */

diff --git a/src/mesa/drivers/dri/i965/brw_ir_fs.h b/src/mesa/drivers/dri/i965/brw_ir_fs.h
index 10da31e8dc7ad7aa471a477b09335bee6d1cff31..19ef242d166841c43409c68fcf913a85b6630bdc 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_ir_fs.h
+++ b/src/mesa/drivers/dri/i965/brw_ir_fs.h
@@ -52,12 +52,6 @@ public:
    /** Smear a channel of the reg to all channels. */
    fs_reg &set_smear(unsigned subreg);
 
-   /**
-    * Offset in bytes from the start of the register.  Values up to a
-    * backend_reg::reg_offset unit are valid.
-    */
-   int subreg_offset;
-
    /** Register region horizontal stride */
    uint8_t stride;
 };
@@ -87,15 +81,15 @@ byte_offset(fs_reg reg, unsigned delta)
    case ATTR:
    case UNIFORM: {
       const unsigned reg_size = (reg.file == UNIFORM ? 4 : REG_SIZE);
-      const unsigned suboffset = reg.subreg_offset + delta;
+      const unsigned suboffset = reg.offset % reg_size + delta;
       reg.offset += ROUND_DOWN_TO(suboffset, reg_size);
-      reg.subreg_offset = suboffset % reg_size;
+      reg.offset = ROUND_DOWN_TO(reg.offset, reg_size) + suboffset % reg_size;
       break;
    }
    case MRF: {
-      const unsigned suboffset = reg.subreg_offset + delta;
+      const unsigned suboffset = reg.offset % REG_SIZE + delta;
       reg.nr += suboffset / REG_SIZE;
-      reg.subreg_offset = suboffset % REG_SIZE;
+      reg.offset = ROUND_DOWN_TO(reg.offset, REG_SIZE) + suboffset % REG_SIZE;
       break;
    }
    case ARF:
@@ -193,7 +187,7 @@ static inline unsigned
 reg_offset(const fs_reg &r)
 {
    return (r.file == VGRF || r.file == IMM ? 0 : r.nr) *
-          (r.file == UNIFORM ? 4 : REG_SIZE) + r.offset + r.subreg_offset;
+          (r.file == UNIFORM ? 4 : REG_SIZE) + r.offset;
 }
 
 /**