Lines Matching refs:reg
45 if (defExists(0) && def(0).rep()->reg.data.id < 0) {
47 if (def(d).rep()->reg.data.id >= 0)
74 if (getDef(d)->refCount() || getDef(d)->reg.data.id >= 0)
110 if (mov->getDef(0)->reg.data.id < 0 && si && si->op != OP_PHI) {
268 if (i->op == OP_PFETCH) // pfetch expects arg1 to be a reg
328 !targ->insnCanLoadOffset(i, s, imm.reg.data.s32))
332 i->src(s).get()->reg.data.offset += imm.reg.data.u32;
336 !targ->insnCanLoadOffset(i, s, -imm.reg.data.s32))
340 i->src(s).get()->reg.data.offset -= imm.reg.data.u32;
343 !targ->insnCanLoadOffset(i, s, imm.reg.data.s32))
347 i->src(s).get()->reg.data.offset += imm.reg.data.u32;
350 !targ->insnCanLoadOffset(i, s, imm.reg.data.s32))
355 i->src(s).get()->reg.data.offset += imm.reg.data.u32;
469 if (imm.reg.data.f32 != 1.0f)
483 if (!bits) // avoid failure if imm.reg.type is unhandled (e.g. b128)
485 switch (imm.reg.type) {
488 imm.reg.data.f32 = fabsf(imm.reg.data.f32);
490 imm.reg.data.f32 = -imm.reg.data.f32;
492 if (imm.reg.data.f32 < 0.0f)
493 imm.reg.data.f32 = 0.0f;
495 if (imm.reg.data.f32 > 1.0f)
496 imm.reg.data.f32 = 1.0f;
508 imm.reg.data.s32 = (imm.reg.data.s32 >= 0) ?
509 imm.reg.data.s32 : -imm.reg.data.s32;
511 imm.reg.data.s32 = -imm.reg.data.s32;
513 imm.reg.data.s32 = ~imm.reg.data.s32;
518 imm.reg.data.f64 = fabs(imm.reg.data.f64);
520 imm.reg.data.f64 = -imm.reg.data.f64;
522 if (imm.reg.data.f64 < 0.0)
523 imm.reg.data.f64 = 0.0;
525 if (imm.reg.data.f64 > 1.0)
526 imm.reg.data.f64 = 1.0;
533 imm.reg.data.u64 = 0;
557 struct Storage *const a = &imm0.reg, *const b = &imm1.reg;
749 i->getSrc(0)->reg.data = res.data;
750 i->getSrc(0)->reg.type = type;
751 i->getSrc(0)->reg.size = typeSizeof(type);
793 struct Storage *const a = &imm0.reg, *const b = &imm1.reg, *const c = &imm2.reg;
867 i->getSrc(0)->reg.data = res.data;
868 i->getSrc(0)->reg.type = i->dType;
869 i->getSrc(0)->reg.size = typeSizeof(i->dType);
882 case OP_NEG: res.data.f32 = -imm.reg.data.f32; break;
883 case OP_ABS: res.data.f32 = fabsf(imm.reg.data.f32); break;
884 case OP_SAT: res.data.f32 = SATURATE(imm.reg.data.f32); break;
885 case OP_RCP: res.data.f32 = 1.0f / imm.reg.data.f32; break;
886 case OP_RSQ: res.data.f32 = 1.0f / sqrtf(imm.reg.data.f32); break;
887 case OP_LG2: res.data.f32 = log2f(imm.reg.data.f32); break;
888 case OP_EX2: res.data.f32 = exp2f(imm.reg.data.f32); break;
889 case OP_SIN: res.data.f32 = sinf(imm.reg.data.f32); break;
890 case OP_COS: res.data.f32 = cosf(imm.reg.data.f32); break;
891 case OP_SQRT: res.data.f32 = sqrtf(imm.reg.data.f32); break;
895 res.data.f32 = imm.reg.data.f32;
913 float f = imm2.reg.data.f32 * exp2f(mul2->postFactor);
930 mul1->setSrc(s1, bld.loadImm(NULL, f * imm1.reg.data.f32));
1063 uint8_t size = i->getDef(0)->reg.size;
1068 uint64_t val = imm0.reg.data.u64;
1071 assert(def->reg.size == size);
1106 imm0.reg.data.u32 = 32 - imm0.reg.data.u32;
1109 i->setSrc(1, new_ImmediateValue(prog, imm0.reg.data.u32));
1145 int64_t b = typeSizeof(i->dType) == 8 ? imm0.reg.data.s64 : imm0.reg.data.s32;
1154 prog, imm0.reg.data.f32 * exp2f(i->postFactor)));
1186 int64_t b = typeSizeof(i->dType) == 8 ? imm0.reg.data.s64 : imm0.reg.data.s32;
1219 if (imm0.reg.data.u32 == 0) {
1222 if (imm0.reg.data.u32 == 1) {
1228 i->setSrc(1, bld.mkImm(util_logbase2(imm0.reg.data.u32)));
1233 const uint32_t d = imm0.reg.data.u32;
1262 if (imm0.reg.data.s32 == -1) {
1268 const int32_t d = imm0.reg.data.s32;
1302 i->setSrc(1, bld.loadImm(NULL, imm0.reg.data.u32 - 1));
1317 bld.loadImm(NULL, imm0.reg.data.u32 - 1));
1354 if (imm0.reg.data.u32 != 0 || !si)
1401 if (imm0.reg.data.u32 == 0) {
1406 } else if (imm0.reg.data.u32 == ~0U) {
1419 if (imm0.reg.data.f32 != 1.0)
1440 util_is_power_of_two_or_zero(imm0.reg.data.u32 + 1)) {
1442 uint32_t ext = (util_last_bit(imm0.reg.data.u32) << 8) | imm1.reg.data.u32;
1449 util_is_power_of_two_or_zero(~imm0.reg.data.u32 + 1) &&
1450 util_last_bit(~imm0.reg.data.u32) <= imm1.reg.data.u32) {
1466 if (imm0.reg.data.u32 == 0) {
1481 i->setSrc(1, bld.loadImm(NULL, imm0.reg.data.u32 + imm1.reg.data.u32));
1485 if (si->src(1).getImmediate(imm1) && imm0.reg.data.u32 == imm1.reg.data.u32) {
1489 i->setSrc(1, bld.loadImm(NULL, ~((1 << imm0.reg.data.u32) - 1)));
1511 i->setSrc(1, bld.loadImm(NULL, imm1.reg.data.u32 << imm0.reg.data.u32));
1533 i->setSrc(adds, bld.loadImm(NULL, imm1.reg.data.u32 << imm0.reg.data.u32));
1537 bld.mkImm(imm0.reg.data.u32)));
1562 case TYPE_S32: res = util_last_bit_signed(imm0.reg.data.s32) - 1; break;
1563 case TYPE_U32: res = util_last_bit(imm0.reg.data.u32) - 1; break;
1577 uint32_t res = util_bitreverse(imm0.reg.data.u32);
1586 uint32_t res = util_bitcount(imm0.reg.data.u32);
1610 CLAMP(imm0.reg.data.f64, fmin, fmax) : \
1611 imm0.reg.data.f64); \
1615 CLAMP(imm0.reg.data.f32, fmin, fmax) : \
1616 imm0.reg.data.f32); \
1620 CLAMP(imm0.reg.data.s32, imin, imax) : \
1621 imm0.reg.data.s32; \
1625 CLAMP(imm0.reg.data.u32, umin, umax) : \
1626 imm0.reg.data.u32; \
1630 CLAMP(imm0.reg.data.s16, imin, imax) : \
1631 imm0.reg.data.s16; \
1635 CLAMP(imm0.reg.data.u16, umin, umax) : \
1636 imm0.reg.data.u16; \
1652 SATURATE(imm0.reg.data.f64) :
1653 imm0.reg.data.f64;
1657 SATURATE(imm0.reg.data.f32) :
1658 imm0.reg.data.f32;
1660 case TYPE_U16: res.data.f32 = (float) imm0.reg.data.u16; break;
1661 case TYPE_U32: res.data.f32 = (float) imm0.reg.data.u32; break;
1662 case TYPE_S16: res.data.f32 = (float) imm0.reg.data.s16; break;
1663 case TYPE_S32: res.data.f32 = (float) imm0.reg.data.s32; break;
1673 SATURATE(imm0.reg.data.f64) :
1674 imm0.reg.data.f64;
1678 SATURATE(imm0.reg.data.f32) :
1679 imm0.reg.data.f32;
1681 case TYPE_U16: res.data.f64 = (double) imm0.reg.data.u16; break;
1682 case TYPE_U32: res.data.f64 = (double) imm0.reg.data.u32; break;
1683 case TYPE_S16: res.data.f64 = (double) imm0.reg.data.s16; break;
1684 case TYPE_S32: res.data.f64 = (double) imm0.reg.data.s32; break;
1879 if (src0->reg.file != FILE_GPR || src1->reg.file != FILE_GPR)
1965 if (src0 != src1 || src0->reg.file != FILE_GPR)
2010 if (slct->getSrc(2)->reg.file == FILE_IMMEDIATE) {
2028 if (src0->reg.file != FILE_GPR || src1->reg.file != FILE_GPR)
2077 set0->getDef(0)->reg.file = FILE_PREDICATE;
2078 set0->getDef(0)->reg.size = 1;
2185 width = (imm.reg.data.u32 >> 8) & 0xff;
2186 offset = imm.reg.data.u32 & 0xff;
2204 if (imm.reg.data.u32 == 0xff)
2206 else if (imm.reg.data.u32 == 0xffff)
2217 ((width == 8 && (imm.reg.data.u32 & 0x7) == 0) ||
2218 (width == 16 && (imm.reg.data.u32 & 0xf) == 0))) {
2220 offset = imm.reg.data.u32;
2229 if (imm.reg.data.u32 == 24) {
2232 } else if (imm.reg.data.u32 == 16) {
2248 ((width == 8 && (imm.reg.data.u32 & 0x7) == 0) ||
2249 (width == 16 && (imm.reg.data.u32 & 0xf) == 0)) &&
2250 imm.reg.data.u32 <= offset) {
2252 offset -= imm.reg.data.u32;
2273 int32_t val = insn->getSrc(2)->asImm()->reg.data.s32;
2296 val += imm.reg.data.s32;
2343 rdsv->getSrc(0)->asSym()->reg.data.sv.sv != SV_COMBINED_TID)
2446 if (src0->reg.file != FILE_GPR || src1->reg.file != FILE_GPR)
2492 add->setSrc(1, new_ImmediateValue(shl->bb->getProgram(), imm.reg.data.u32));
2626 if (i->getSrc(0)->reg.size == 8)
2633 if (i->getSrc(1)->reg.size == 8)
2642 if (i->getSrc(2)->reg.size == 8)
2683 if (offset != ldst->getSrc(0)->reg.data.offset) {
2686 ldst->getSrc(0)->reg.data.offset = offset;
2778 int32_t offLd = ld->getSrc(0)->reg.data.offset;
2785 isAccessSupported(ld->getSrc(0)->reg.file, typeOfSize(size)))
2801 for (j = 0; sizeRc; sizeRc -= rec->insn->getDef(j)->reg.size, ++j);
2805 for (sz = 0, d = 0; sz < sizeLd; sz += ld->getDef(d)->reg.size, ++d);
2813 rec->offset = rec->insn->getSrc(0)->reg.data.offset = offLd;
2821 sizeLd -= ld->getDef(j)->reg.size;
2826 rec->insn->getSrc(0)->reg.size = size;
2838 int32_t offSt = st->getSrc(0)->reg.data.offset;
2848 isAccessSupported(st->getSrc(0)->reg.file, typeOfSize(size)))
2862 st->getSrc(0)->reg.file == FILE_SHADER_OUTPUT &&
2876 sizeSt -= st->getSrc(s + 1)->reg.size;
2881 sizeRc -= rec->insn->getSrc(j)->reg.size;
2891 sizeSt -= st->getSrc(j)->reg.size;
2893 sizeRc -= rec->insn->getSrc(s)->reg.size;
2903 rec->insn->getSrc(0)->reg.size = size;
2912 fileIndex = mem->reg.fileIndex;
2915 offset = mem->reg.data.offset;
2967 Record *it = load ? loads[sym->reg.file] : stores[sym->reg.file];
2972 if ((it->offset >> 4) != (sym->reg.data.offset >> 4) ||
2974 it->fileIndex != sym->reg.fileIndex ||
2978 if (it->offset < sym->reg.data.offset) {
2979 if (it->offset + it->size >= sym->reg.data.offset) {
2980 isAdj = (it->offset + it->size == sym->reg.data.offset);
2987 isAdj = it->offset != sym->reg.data.offset;
2991 if (!(sym->reg.data.offset & 0x7))
2992 if (it->offset - size <= sym->reg.data.offset)
3004 int32_t offLd = ld->getSrc(0)->reg.data.offset;
3008 offSt += st->getSrc(s)->reg.size;
3013 if (ld->getDef(d)->reg.size != st->getSrc(s)->reg.size)
3015 if (st->getSrc(s)->reg.file != FILE_GPR)
3028 int32_t offE = ldE->getSrc(0)->reg.data.offset;
3033 offR += ldR->getDef(dR)->reg.size;
3038 if (ldE->getDef(dE)->reg.size != ldR->getDef(dR)->reg.size)
3053 int32_t offS = st->getSrc(0)->reg.data.offset;
3067 for (s = 1; offR < offS; offR += ri->getSrc(s)->reg.size, ++s)
3071 for (s = 1; st->srcExists(s); offS += st->getSrc(s)->reg.size, ++s)
3074 for (s = n; offR < endS; offR += ri->getSrc(s)->reg.size, ++s);
3076 for (; offR < endR; offR += ri->getSrc(s)->reg.size, ++s)
3085 for (j = 1; offR < endS; offR += ri->getSrc(j++)->reg.size);
3086 for (s = 1; offS < endS; offS += st->getSrc(s++)->reg.size);
3087 for (; offR < endR; offR += ri->getSrc(j++)->reg.size)
3095 rec->offset = st->getSrc(0)->reg.data.offset;
3317 int bytes = v->reg.data.id * MIN2(v->reg.size, 4);
3351 pred->join->reg.data.id = -1; // deallocate
3562 i->getDef(0)->reg.data.id != i->getSrc(2)->reg.data.id)
3565 if (i->getDef(0)->reg.data.id >= 64 ||
3566 i->getSrc(0)->reg.data.id >= 64)
3569 if (i->flagsSrc >= 0 && i->getSrc(i->flagsSrc)->reg.data.id != 0)
3590 if (i->getSrc(1)->reg.data.id & 1)
3591 val.reg.data.u32 >>= 16;
3592 val.reg.data.u32 &= 0xffff;
3593 i->setSrc(1, new_ImmediateValue(prog, val.reg.data.u32));
3618 i->getDef(0)->reg.data.id != i->getSrc(2)->reg.data.id)
3994 if (!ld1->getDef(d)->refCount() && ld1->getDef(d)->reg.data.id < 0)
3999 addr1 = ld1->getSrc(0)->reg.data.offset;
4009 size1 += def1[n1++]->reg.size;
4012 addr1 += ld1->getDef(d)->reg.size;
4021 !prog->getTarget()->isAccessSupported(ld1->getSrc(0)->reg.file,
4023 size1 -= def1[--n1]->reg.size;
4032 size2 += def2[n2++]->reg.size;
4035 addr2 += ld1->getDef(d)->reg.size;