From: <eri...@us...> - 2010-07-08 15:24:07
|
Revision: 15884 http://jikesrvm.svn.sourceforge.net/jikesrvm/?rev=15884&view=rev Author: eris2006 Date: 2010-07-08 15:24:01 +0000 (Thu, 08 Jul 2010) Log Message: ----------- First Commit Modified Paths: -------------- rvmroot/branches/RVM-RegAlloc-ELS/trunk/rvm/src/org/jikesrvm/compilers/opt/regalloc/GenericRegisterRestrictions.java Modified: rvmroot/branches/RVM-RegAlloc-ELS/trunk/rvm/src/org/jikesrvm/compilers/opt/regalloc/GenericRegisterRestrictions.java =================================================================== --- rvmroot/branches/RVM-RegAlloc-ELS/trunk/rvm/src/org/jikesrvm/compilers/opt/regalloc/GenericRegisterRestrictions.java 2010-07-08 15:23:32 UTC (rev 15883) +++ rvmroot/branches/RVM-RegAlloc-ELS/trunk/rvm/src/org/jikesrvm/compilers/opt/regalloc/GenericRegisterRestrictions.java 2010-07-08 15:24:01 UTC (rev 15884) @@ -16,6 +16,9 @@ import java.util.Enumeration; import java.util.HashMap; import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + import org.jikesrvm.ArchitectureSpecificOpt.PhysicalRegisterSet; import org.jikesrvm.VM; import org.jikesrvm.compilers.opt.ir.BasicBlock; @@ -25,6 +28,9 @@ import static org.jikesrvm.compilers.opt.ir.Operators.CALL_SAVE_VOLATILE; import static org.jikesrvm.compilers.opt.ir.Operators.YIELDPOINT_OSR; import org.jikesrvm.compilers.opt.ir.Register; +import org.jikesrvm.compilers.opt.regalloc.LinearScan.CompoundInterval; +import org.jikesrvm.compilers.opt.regalloc.LinearScan.Interval; +import org.jikesrvm.compilers.opt.regalloc.LinearScan.MappedBasicInterval; import org.jikesrvm.compilers.opt.util.BitSet; /** @@ -38,12 +44,15 @@ // for each symbolic register, the set of physical registers that are // illegal for assignment private final HashMap<Register, RestrictedRegisterSet> hash = new HashMap<Register, RestrictedRegisterSet>(); - // a set of symbolic registers that must not be spilled. private final HashSet<Register> noSpill = new HashSet<Register>(); - protected final PhysicalRegisterSet phys; - + private final HashMap<Interval,RestrictedRegisterSet> intervalHash = new HashMap<Interval,RestrictedRegisterSet>(); + private final HashSet<Interval> intervalNoSpill = new HashSet<Interval>(); + + /* present for testing purpose and must be removed before commit*/ + private boolean forceitfornow= true; + /** * Default Constructor */ @@ -58,6 +67,9 @@ protected final void noteMustNotSpill(Register r) { noSpill.add(r); } + protected final void noteMustNotSpill(Interval I) { + intervalNoSpill.add(I); + } /** * Is spilling a register forbidden? @@ -65,7 +77,9 @@ public final boolean mustNotSpill(Register r) { return noSpill.contains(r); } - + public final boolean mustNotSpill(Interval I) { + return intervalNoSpill.contains(I); + } /** * Record all the register restrictions dictated by an IR. * @@ -80,7 +94,58 @@ processBlock(b); } } - +public void iterateOverSet(){ + Iterator<Interval> iKeys = intervalHash.keySet().iterator(); + Iterator<Register> rKeys = hash.keySet().iterator(); + Iterator<Register> noSpillRegisters = noSpill.iterator(); + Iterator<Interval> noSpillIntervals = intervalNoSpill.iterator(); + + System.out.println("intervals and its restrcited register set"); + while(iKeys.hasNext()){ + Enumeration<Register> enume = phys.enumerateAll(); + Interval i = iKeys.next(); + RestrictedRegisterSet set = intervalHash.get(i); + MappedBasicInterval m = (MappedBasicInterval)i; + System.out.println("Basic Interval's reg "+m.container.getRegister().toString()); + while(enume.hasMoreElements()){ + Register temp = enume.nextElement(); + if(set.contains(temp)) + temp.toString(); + } + } + + System.out.println("Register and its restrcited register set"); + while(rKeys.hasNext()){ + Enumeration<Register> enume = phys.enumerateAll(); + Register reg = rKeys.next(); + + System.out.println("CompoundInterval Interval's reg "+reg.toString()); + RestrictedRegisterSet set = hash.get(reg); + BitSet s =set.bitset; + while(enume.hasMoreElements()){ + Register temp = enume.nextElement(); + if(set.contains(temp)) + temp.toString(); + + } + + } + + while(noSpillIntervals.hasNext()){ + System.out.println("interval/ Register which cannot be spilled"); + Interval i = noSpillIntervals.next(); + MappedBasicInterval m = (MappedBasicInterval)i; + System.out.println("Contains Registernum "+ m.container.getRegister().number); + + } + + while(noSpillRegisters.hasNext()){ + System.out.println(" Register which cannot be spilled"); + Register reg = noSpillRegisters.next(); + + System.out.println("Contains Registernum "+ reg.number); + } +} /** * Record all the register restrictions dictated by live ranges on a * particular basic block. @@ -92,7 +157,7 @@ private void processBlock(BasicBlock bb) { ArrayList<LiveIntervalElement> symbolic = new ArrayList<LiveIntervalElement>(20); ArrayList<LiveIntervalElement> physical = new ArrayList<LiveIntervalElement>(20); - + Interval i; // 1. walk through the live intervals and identify which correspond to // physical and symbolic registers for (Enumeration<LiveIntervalElement> e = bb.enumerateLiveIntervals(); e.hasMoreElements();) { @@ -113,7 +178,10 @@ for (LiveIntervalElement phys : physical) { for (LiveIntervalElement symb : symbolic) { if (overlaps(phys, symb)) { - addRestriction(symb.getRegister(), phys.getRegister()); + i = symb.getInterval(); + VM._assert(i != null); + addRestriction(symb.getRegister(), phys.getRegister()); + addRestriction(i, phys.getRegister()); } } } @@ -126,7 +194,12 @@ if (s.operator.isCall() && s.operator != CALL_SAVE_VOLATILE) { for (LiveIntervalElement symb : symbolic) { if (contains(symb, s.scratch)) { - forbidAllVolatiles(symb.getRegister()); + i = symb.getInterval(); + VM._assert(i != null); + if(i instanceof CompoundInterval) + forbidAllVolatiles(symb.getRegister()); + else + forbidAllVolatiles(i); } } } @@ -139,7 +212,12 @@ for (LiveIntervalElement symb : symbolic) { if (symb.getRegister().isFloatingPoint()) { if (contains(symb, s.scratch)) { - forbidAllVolatiles(symb.getRegister()); + i = symb.getInterval(); + VM._assert(i != null); + if(i instanceof CompoundInterval) + forbidAllVolatiles(symb.getRegister()); + else + forbidAllVolatiles(i); } } } @@ -228,7 +306,16 @@ } r.setNoVolatiles(); } + final void forbidAllVolatiles(Interval I) { + RestrictedRegisterSet r = intervalHash.get(I); + if (r == null) { + r = new RestrictedRegisterSet(phys); + intervalHash.put(I, r); + } + r.setNoVolatiles(); + } + /** * Record that it is illegal to assign a symbolic register symb to any * of a set of physical registers @@ -241,7 +328,14 @@ } r.addAll(set); } - + protected final void addRestrictions(Interval I, BitSet set) { + RestrictedRegisterSet r = intervalHash.get(I); + if (r == null) { + r = new RestrictedRegisterSet(phys); + intervalHash.put(I, r); + } + r.addAll(set); + } /** * Record that it is illegal to assign a symbolic register symb to a * physical register p @@ -254,14 +348,29 @@ } r.add(p); } - /** + * Record that it is illegal to assign a symbolic register symb to a + * physical register p + */ + protected final void addRestriction(Interval I, Register p) { + RestrictedRegisterSet r = intervalHash.get(I); + if (r == null) { + r = new RestrictedRegisterSet(phys); + intervalHash.put(I, r); + } + r.add(p); + } + /** * Return the set of restricted physical register for a given symbolic * register. Return null if no restrictions. */ final RestrictedRegisterSet getRestrictions(Register symb) { return hash.get(symb); } + + final RestrictedRegisterSet getRestrictions(Interval I) { + return intervalHash.get(I); + } /** * Is it forbidden to assign symbolic register symb to any volatile @@ -277,7 +386,15 @@ if (s == null) return false; return s.getNoVolatiles(); } - + + public final boolean allVolatilesForbidden(Interval I) { + if (VM.VerifyAssertions) { + VM._assert(I != null); + } + RestrictedRegisterSet s = getRestrictions(I); + if (s == null) return false; + return s.getNoVolatiles(); + } /** * Is it forbidden to assign symbolic register symb to physical register * phys? @@ -291,7 +408,16 @@ if (s == null) return false; return s.contains(phys); } - + + public final boolean isForbidden(Interval I, Register phys) { + if (VM.VerifyAssertions) { + VM._assert(I != null); + VM._assert(phys != null); + } + RestrictedRegisterSet s = getRestrictions(I); + if (s == null) return false; + return s.contains(phys); + } /** * Is it forbidden to assign symbolic register symb to physical register r * in instruction s? This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |