Lines Matching defs:reg

39    fs_reg(struct ::brw_reg reg);
58 negate(fs_reg reg)
60    assert(reg.file != IMM);
61    reg.negate = !reg.negate;
62    return reg;
66 retype(fs_reg reg, enum brw_reg_type type)
68    reg.type = type;
69    return reg;
73 byte_offset(fs_reg reg, unsigned delta)
75    switch (reg.file) {
81       reg.offset += delta;
84       const unsigned suboffset = reg.offset + delta;
85       reg.nr += suboffset / REG_SIZE;
86       reg.offset = suboffset % REG_SIZE;
91       const unsigned suboffset = reg.subnr + delta;
92       reg.nr += suboffset / REG_SIZE;
93       reg.subnr = suboffset % REG_SIZE;
100    return reg;
104 horiz_offset(const fs_reg &reg, unsigned delta)
106    switch (reg.file) {
114       return reg;
118       return byte_offset(reg, delta * reg.stride * type_sz(reg.type));
121       if (reg.is_null()) {
122          return reg;
124          const unsigned stride = reg.hstride ? 1 << (reg.hstride - 1) : 0;
125          return byte_offset(reg, delta * stride * type_sz(reg.type));
132 offset(fs_reg reg, unsigned width, unsigned delta)
134    switch (reg.file) {
143       return byte_offset(reg, delta * reg.component_size(width));
147    return reg;
151  * Get the scalar channel of \p reg given by \p idx and replicate it to all
155 component(fs_reg reg, unsigned idx)
157    reg = horiz_offset(reg, idx);
158    reg.stride = 0;
159    return reg;
248 is_periodic(const fs_reg &reg, unsigned n)
250    if (reg.file == BAD_FILE || reg.is_null()) {
253    } else if (reg.file == IMM) {
254       const unsigned period = (reg.type == BRW_REGISTER_TYPE_UV ||
255                                reg.type == BRW_REGISTER_TYPE_V ? 8 :
256                                reg.type == BRW_REGISTER_TYPE_VF ? 4 :
260    } else if (reg.file == ARF || reg.file == FIXED_GRF) {
261       const unsigned period = (reg.hstride == 0 && reg.vstride == 0 ? 1 :
262                                reg.vstride == 0 ? 1 << reg.width :
267       return reg.stride == 0;
272 is_uniform(const fs_reg &reg)
274    return is_periodic(reg, 1);
281 quarter(const fs_reg &reg, unsigned idx)
284    return horiz_offset(reg, 8 * idx);
288  * Reinterpret each channel of register \p reg as a vector of values of the
292 subscript(fs_reg reg, brw_reg_type type, unsigned i)
294    assert((i + 1) * type_sz(type) <= type_sz(reg.type));
296    if (reg.file == ARF || reg.file == FIXED_GRF) {
300       const int delta = util_logbase2(type_sz(reg.type)) -
302       reg.hstride += (reg.hstride ? delta : 0);
303       reg.vstride += (reg.vstride ? delta : 0);
305    } else if (reg.file == IMM) {
307       reg.u64 >>= i * bit_size;
308       reg.u64 &= BITFIELD64_MASK(bit_size);
310          reg.u64 |= reg.u64 << 16;
311       return retype(reg, type);
313       reg.stride *= type_sz(reg.type) / type_sz(type);
316    return byte_offset(retype(reg, type), i * type_sz(type));
320 horiz_stride(fs_reg reg, unsigned s)
322    reg.stride *= s;
323    return reg;
632       fs_reg reg = inst->src[0];
635          reg.type = inst->src[i].type;
636          if (!inst->src[i].equals(reg))
639          reg = byte_offset(reg, inst->size_read(i));