/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); boolean changed = false; if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }
/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); boolean changed = false; if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }
/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }
/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); boolean changed = false; if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }
/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); boolean changed = false; if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }
/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); boolean changed = false; if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }
/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); boolean changed = false; if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }
/** * Merges the given register set into the set for the block with the * given index. If there was not already an associated set, then this * is the same as calling {@link #setStarts}. Otherwise, this will * merge the two sets and call {@link #setStarts} on the result of the * merge. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to merge into the start set * for the block * @return {@code true} if the merge resulted in an actual change * to the associated set (including storing one for the first time) or * {@code false} if there was no change */ public boolean mergeStarts(int index, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(index); boolean changed = false; if (start == null) { setStarts(index, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(index, newStart); return true; }