/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Sets the register set associated with the start of the block with * the given label. * * @param label {@code >= 0;} the block label * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int label, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[label] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus label"); } }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }
/** * Adds an assignment association for the given instruction and * register spec. This throws an exception if the instruction * doesn't actually perform a named variable assignment. * * <b>Note:</b> Although the instruction contains its own spec for * the result, it still needs to be passed in explicitly to this * method, since the spec that is stored here should always have a * simple type and the one in the instruction can be an arbitrary * {@link TypeBearer} (such as a constant value). * * @param insn {@code non-null;} the instruction in question * @param spec {@code non-null;} the associated register spec */ public void addAssignment(Insn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }