/** * Gets the instruction that is equivalent to this one, except that * it uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). * * @return {@code non-null;} the replacement */ public DalvInsn getLowRegVersion() { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), null); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). * * @return {@code non-null;} the replacement */ public DalvInsn getLowRegVersion() { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), null); return withRegisters(regs); }
/** * Returns an instance that is just like this one, except that the * register list is mapped by using {@code mapper}. * * @param mapper {@code non-null;} used to map registers * @return {@code non-null;} an appropriately-constructed instance */ public DalvInsn withMapper(RegisterMapper mapper) { return withRegisters(mapper.map(getRegisters())); }
/** * Returns an instance that is just like this one, except that the * register list is mapped by using {@code mapper}. * * @param mapper {@code non-null;} used to map registers * @return {@code non-null;} an appropriately-constructed instance */ public DalvInsn withMapper(RegisterMapper mapper) { return withRegisters(mapper.map(getRegisters())); }
/** * Gets the instruction that is equivalent to this one, except that * it uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). * * @return {@code non-null;} the replacement */ public DalvInsn getLowRegVersion() { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), null); return withRegisters(regs); }
/** * Returns an instance that is just like this one, except that the * register list is mapped by using {@code mapper}. * * @param mapper {@code non-null;} used to map registers * @return {@code non-null;} an appropriately-constructed instance */ public DalvInsn withMapper(RegisterMapper mapper) { return withRegisters(mapper.map(getRegisters())); }
/** * Gets the instruction that is equivalent to this one, except that * it uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). * * @return {@code non-null;} the replacement */ public DalvInsn getLowRegVersion() { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), null); return withRegisters(regs); }
/** * Returns an instance that is just like this one, except that the * register list is mapped by using {@code mapper}. * * @param mapper {@code non-null;} used to map registers * @return {@code non-null;} an appropriately-constructed instance */ public DalvInsn withMapper(RegisterMapper mapper) { return withRegisters(mapper.map(getRegisters())); }
/** * Gets the instruction that is equivalent to this one, except that * it uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). * * @return {@code non-null;} the replacement */ public DalvInsn getLowRegVersion() { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), null); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). * * @return {@code non-null;} the replacement */ public DalvInsn getLowRegVersion() { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), null); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). * * @return {@code non-null;} the replacement */ public DalvInsn getLowRegVersion() { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), null); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it replaces incompatible registers with sequential registers * starting at {@code 0} (storing the result, if any, in register * {@code 0} as well). The sequence of instructions from * {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) * surrounding the result of a call to this method are the expanded * transformation of this instance, and it is guaranteed that the * number of low registers used will be the number returned by * {@link #getMinimumRegisterRequirement}. * * @param compatRegs {@code non-null;} set of compatible registers * @return {@code non-null;} the replacement */ public DalvInsn expandedVersion(BitSet compatRegs) { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), compatRegs); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it replaces incompatible registers with sequential registers * starting at {@code 0} (storing the result, if any, in register * {@code 0} as well). The sequence of instructions from * {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) * surrounding the result of a call to this method are the expanded * transformation of this instance, and it is guaranteed that the * number of low registers used will be the number returned by * {@link #getMinimumRegisterRequirement}. * * @param compatRegs {@code non-null;} set of compatible registers * @return {@code non-null;} the replacement */ public DalvInsn expandedVersion(BitSet compatRegs) { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), compatRegs); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * uses sequential registers starting at {@code 0} (storing * the result, if any, in register {@code 0} as well). The * sequence of instructions from {@link #hrPrefix} and {@link * #hrSuffix} (if non-null) surrounding the result of a call to * this method are the high register transformation of this * instance, and it is guaranteed that the number of low registers * used will be the number returned by {@link * #getMinimumRegisterRequirement}. * * @return {@code non-null;} the replacement */ public DalvInsn hrVersion() { RegisterSpecList regs = registers.withSequentialRegisters(0, hasResult()); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it replaces incompatible registers with sequential registers * starting at {@code 0} (storing the result, if any, in register * {@code 0} as well). The sequence of instructions from * {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) * surrounding the result of a call to this method are the expanded * transformation of this instance, and it is guaranteed that the * number of low registers used will be the number returned by * {@link #getMinimumRegisterRequirement}. * * @param compatRegs {@code non-null;} set of compatible registers * @return {@code non-null;} the replacement */ public DalvInsn expandedVersion(BitSet compatRegs) { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), compatRegs); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it replaces incompatible registers with sequential registers * starting at {@code 0} (storing the result, if any, in register * {@code 0} as well). The sequence of instructions from * {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) * surrounding the result of a call to this method are the expanded * transformation of this instance, and it is guaranteed that the * number of low registers used will be the number returned by * {@link #getMinimumRegisterRequirement}. * * @param compatRegs {@code non-null;} set of compatible registers * @return {@code non-null;} the replacement */ public DalvInsn expandedVersion(BitSet compatRegs) { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), compatRegs); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it replaces incompatible registers with sequential registers * starting at {@code 0} (storing the result, if any, in register * {@code 0} as well). The sequence of instructions from * {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) * surrounding the result of a call to this method are the expanded * transformation of this instance, and it is guaranteed that the * number of low registers used will be the number returned by * {@link #getMinimumRegisterRequirement}. * * @param compatRegs {@code non-null;} set of compatible registers * @return {@code non-null;} the replacement */ public DalvInsn expandedVersion(BitSet compatRegs) { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), compatRegs); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it replaces incompatible registers with sequential registers * starting at {@code 0} (storing the result, if any, in register * {@code 0} as well). The sequence of instructions from * {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) * surrounding the result of a call to this method are the expanded * transformation of this instance, and it is guaranteed that the * number of low registers used will be the number returned by * {@link #getMinimumRegisterRequirement}. * * @param compatRegs {@code non-null;} set of compatible registers * @return {@code non-null;} the replacement */ public DalvInsn expandedVersion(BitSet compatRegs) { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), compatRegs); return withRegisters(regs); }
/** * Gets the instruction that is equivalent to this one, except that * it replaces incompatible registers with sequential registers * starting at {@code 0} (storing the result, if any, in register * {@code 0} as well). The sequence of instructions from * {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) * surrounding the result of a call to this method are the expanded * transformation of this instance, and it is guaranteed that the * number of low registers used will be the number returned by * {@link #getMinimumRegisterRequirement}. * * @param compatRegs {@code non-null;} set of compatible registers * @return {@code non-null;} the replacement */ public DalvInsn expandedVersion(BitSet compatRegs) { RegisterSpecList regs = registers.withExpandedRegisters(0, hasResult(), compatRegs); return withRegisters(regs); }