/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldSpec {@code non-null;} old namespace register * @param newReg new namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(RegisterSpec oldSpec, int newReg) { return interferes(oldSpec.getReg(), newReg, oldSpec.getCategory()); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldReg old namespace register * @param newReg new namespace register * @param category category of old namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(int oldReg, int newReg, int category) { if (newReg >= newRegInterference.size()) { return false; } else { IntSet existing = newRegInterference.get(newReg); if (existing == null) { return false; } else if (category == 1) { return existing.has(oldReg); } else { return existing.has(oldReg) || (interferes(oldReg, newReg+1, category-1)); } } }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldReg old namespace register * @param newReg new namespace register * @param category category of old namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(int oldReg, int newReg, int category) { if (newReg >= newRegInterference.size()) { return false; } else { IntSet existing = newRegInterference.get(newReg); if (existing == null) { return false; } else if (category == 1) { return existing.has(oldReg); } else { return existing.has(oldReg) || (interferes(oldReg, newReg+1, category-1)); } } }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if {@code ssaSpec} can be mapped to * {@code ropReg}. Checks interference graph and ensures * the range does not cross the parameter range. * * @param ssaSpec {@code non-null;} SSA spec * @param ropReg prosepctive new-namespace reg * @return {@code true} if mapping is possible */ private boolean canMapReg(RegisterSpec ssaSpec, int ropReg) { int category = ssaSpec.getCategory(); return !(spansParamRange(ropReg, category) || mapper.interferes(ssaSpec, ropReg)); }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldReg old namespace register * @param newReg new namespace register * @param category category of old namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(int oldReg, int newReg, int category) { if (newReg >= newRegInterference.size()) { return false; } else { IntSet existing = newRegInterference.get(newReg); if (existing == null) { return false; } else if (category == 1) { return existing.has(oldReg); } else { return existing.has(oldReg) || (interferes(oldReg, newReg+1, category-1)); } } }
/** * Checks to see if old namespace reg {@code oldReg} interferes * with what currently maps to {@code newReg}. * * @param oldReg old namespace register * @param newReg new namespace register * @param category category of old namespace register * @return true if oldReg will interfere with newReg */ public boolean interferes(int oldReg, int newReg, int category) { if (newReg >= newRegInterference.size()) { return false; } else { IntSet existing = newRegInterference.get(newReg); if (existing == null) { return false; } else if (category == 1) { return existing.has(oldReg); } else { return existing.has(oldReg) || (interferes(oldReg, newReg+1, category-1)); } } }