Lines Matching defs:vreg
107 vreg. Is safely left at False, and becomes True after a
113 Bound /* in use (holding value of some vreg) */
116 /* If .disp == Bound, what vreg is it bound to? */
117 HReg vreg;
123 (vreg_state) from vreg numbers back to entries in rreg_state. It
125 hregNumber(rreg_state[j].vreg) == i -- that is, the two entries
127 which involve looking for a particular vreg: there is no need to
129 vreg_state. The FAQ "does this vreg already have an associated
132 To indicate, in vreg_state[i], that a given vreg is not currently
165 finding the vreg which is mentioned as far ahead as possible, in
195 instrs_in->arr[m], state[k].vreg, mode64))
207 /* Check that this vreg has been assigned a sane spill offset. */
208 static inline void sanity_check_spill_offset ( VRegLR* vreg )
210 switch (vreg->reg_class) {
212 vassert(0 == ((UShort)vreg->spill_offset % 16)); break;
214 vassert(0 == ((UShort)vreg->spill_offset % 8)); break;
301 vreg numbers 0, 1 .. n_vregs-1. Appearance of a vreg outside
353 HReg rreg, vreg, vregS, vregD;
391 /* The vreg -> rreg map constructed and then applied to each
435 (*ppReg)(rreg_state[z].vreg); \
473 rreg_state[j].vreg = INVALID_HREG;
482 /* --------- Stage 1: compute vreg live ranges. --------- */
485 /* ------ start of SET UP TO COMPUTE VREG LIVE RANGES ------ */
488 vreg, and are not interested in
505 /* ------ end of SET UP TO COMPUTE VREG LIVE RANGES ------ */
544 /* ------ start of DEAL WITH VREG LIVE RANGES ------ */
549 vreg = reg_usage.hreg[j];
551 if (!hregIsVirtual(vreg))
553 k = hregNumber(vreg);
558 vex_printf("vreg %d, n_vregs %d\n", k, n_vregs);
559 vpanic("doRegisterAllocation: out-of-range vreg");
565 /* First mention of this vreg. */
566 vreg_lrs[k].reg_class = hregClass(vreg);
569 vassert(vreg_lrs[k].reg_class == hregClass(vreg));
576 vex_printf("\n\nOFFENDING VREG = %d\n", k);
578 "first event for vreg is Read");
589 vex_printf("\n\nOFFENDING VREG = %d\n", k);
591 "first event for vreg is Modify");
601 /* ------ end of DEAL WITH VREG LIVE RANGES ------ */
768 vex_printf("vreg %d: la = %d, db = %d\n",
823 /* True iff this vreg is unused. In which case we also expect
832 to spill a vreg of class Flt64 or Vec128, we'll need to find
841 provide up to 128 bits in which to spill the vreg.
889 vex_printf("vreg %d --> spill offset %d\n",
897 establish which, if any, rreg each vreg would prefer to be in.
989 /* Sanity check 3: all vreg-rreg bindings must bind registers
997 == hregClass(rreg_state[j].vreg));
998 vassert( hregIsVirtual(rreg_state[j].vreg));
1004 rreg_state[j].vreg points at some vreg_state entry then
1010 k = hregNumber(rreg_state[j].vreg);
1020 vassert(hregNumber(rreg_state[k].vreg) == j);
1056 && sameHReg(rreg_state[m].vreg, vregS))
1066 rreg_state[m].vreg = vregD;
1072 /* This rreg has become associated with a different vreg and
1091 UInt vregno = hregNumber(rreg_state[j].vreg);
1096 m = hregNumber(rreg_state[j].vreg);
1111 one of their live ranges. If any such rreg holds a vreg, we
1151 m = hregNumber(rreg_state[k].vreg);
1153 /* Yes, there is an associated vreg. Spill it if it's
1174 rreg_state[k].vreg = INVALID_HREG;
1195 We also build up the final vreg->rreg mapping to be applied
1204 /* If the instruction reads exactly one vreg which is currently
1205 in a spill slot, and this is last use of that vreg, see if we
1221 vreg = reg_usage.hreg[j];
1223 if (!hregIsVirtual(vreg))
1228 m = hregNumber(vreg);
1237 cand = vreg;
1275 vreg = reg_usage.hreg[j];
1278 if (!hregIsVirtual(vreg))
1282 vex_printf("considering "); (*ppReg)(vreg); vex_printf("\n");
1285 /* Now we're trying to find a rreg for "vreg". First of all,
1288 m = hregNumber(vreg);
1293 addToHRegRemap(&remap, vreg, rreg_state[k].rreg);
1311 || hregClass(rreg_state[k].rreg) != hregClass(vreg))
1328 rreg_state[k].vreg = vreg;
1329 m = hregNumber(vreg);
1332 addToHRegRemap(&remap, vreg, rreg_state[k].rreg);
1335 guarantee that the first event for a vreg is a write.
1337 the first reference for this vreg, and so a reload is
1366 /* Well, now we have no option but to spill a vreg. It's
1367 important to make a good choice of vreg to spill, and of
1368 course we need to be careful not to spill a vreg which is
1372 candidates, due to holding a vreg mentioned by this
1378 if (hregClass(rreg_state[k].rreg) != hregClass(vreg))
1382 if (sameHReg(rreg_state[k].vreg, reg_usage.hreg[m])) {
1391 the next use of its associated vreg is as far ahead as
1402 ppHRegClass(hregClass(vreg));
1411 vassert(hregClass(rreg_state[spillee].rreg) == hregClass(vreg));
1412 /* check we're not ejecting the vreg for which we are trying
1414 vassert(! sameHReg(rreg_state[spillee].vreg, vreg));
1416 m = hregNumber(rreg_state[spillee].vreg);
1420 live vreg. */
1437 rreg_state[spillee].vreg = vreg;
1442 m = hregNumber(vreg);
1446 /* Now, if this vreg is being read or modified (as opposed to
1470 /* So after much twisting and turning, we have vreg mapped to
1472 addToHRegRemap(&remap, vreg, rreg_state[spillee].rreg);
1479 - a suitable vreg->rreg mapping for this instruction has been
1519 rreg_state[k].vreg = INVALID_HREG;
