/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given label. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param label {@code >= 0;} the block label * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int label) { RegisterSpecSet result = getStarts0(label); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
/** * Gets a mutable copy of the register set associated with the * start of the block with the given index. This returns a * newly-allocated empty {@link RegisterSpecSet} of appropriate * max size if there is not yet any set associated with the block. * * @param index {@code >= 0;} the block index * @return {@code non-null;} the associated register set */ public RegisterSpecSet mutableCopyOfStarts(int index) { RegisterSpecSet result = getStarts0(index); return (result != null) ? result.mutableCopy() : new RegisterSpecSet(regCount); }
RegisterSpecSet newStart = start.mutableCopy(); if (start.size() != 0) { newStart.intersect(specs, true); } else { newStart = specs.mutableCopy();
/** * Merges the given register set into the set for the block with the * given label. 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 label {@code >= 0;} the block label * @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 label, RegisterSpecSet specs) { RegisterSpecSet start = getStarts0(label); boolean changed = false; if (start == null) { setStarts(label, specs); return true; } RegisterSpecSet newStart = start.mutableCopy(); newStart.intersect(specs, true); if (start.equals(newStart)) { return false; } newStart.setImmutable(); setStarts(label, 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; }