/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * Sets the register set associated with the start of the block with * the given index. * * @param index {@code >= 0;} the block index * @param specs {@code non-null;} the register set to associate with the block */ public void setStarts(int index, RegisterSpecSet specs) { throwIfImmutable(); if (specs == null) { throw new NullPointerException("specs == null"); } try { blockStarts[index] = specs; } catch (ArrayIndexOutOfBoundsException ex) { // Translate the exception. throw new IllegalArgumentException("bogus index"); } }
/** * 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 com.android.dx.rop.type.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(SsaInsn 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 com.android.dx.rop.type.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(SsaInsn 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 com.android.dx.rop.type.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(SsaInsn 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 com.android.dx.rop.type.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(SsaInsn 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 com.android.dx.rop.type.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(SsaInsn 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 com.android.dx.rop.type.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(SsaInsn 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 com.android.dx.rop.type.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(SsaInsn 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 com.android.dx.rop.type.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(SsaInsn insn, RegisterSpec spec) { throwIfImmutable(); if (insn == null) { throw new NullPointerException("insn == null"); } if (spec == null) { throw new NullPointerException("spec == null"); } insnAssignments.put(insn, spec); }